Тестирование компилятора СИ

МИНИСТЕРСТВО ОБРАЗОВАНИЯ РОССИЙСКОЙ ФЕДЕРАЦИИ

ФАКУЛЬТЕТ КИБЕРНЕТИКИ

ДИПЛОМНЫЙ ПРОЕКТ

Тема : «Разработка механизмов тестирования компиляторов языка программирования Си на соответствие стандарту ANSI ISO/IEC 9899:1999 в части декларативных операторов »

Дипломник

Шифр зачетной книжки ____________________________________________

Руководитель проекта

Консультант по спец. части

Консультант по организационно-экономической части

Консультант по охране труда

Рецензент

Москва 2004

Содержание.

Часть 1 Основная часть

1. Введение.

В начале 70-х годов многие специалисты пришли к выводу о необходимости широкого распро­странения индустриальных (инженерных) методов в области по­строения программ. Индустриальные методы бази­руются на строгой регламентации и автоматизации технологиче­ских процессов. Таким образом, стандартизация и в области по­строения программ стала жизненной необходимостью.

К настоящему времени накоплен богатый опыт стандартизации языков программирования. Разработаны и активно применяются стандарты большинства промышленных языков программирования. Создаются метастандарты языковых стандартов.

Одна из основных проблем стандартизации языков программирования - проблема контроля стандартов. В особенности это верно для языковых процессоров. Практически все существенные требования, касающиеся их поведения, алгоритмически неразрешимы. Важнейший аспект контроля конформности (т.е. согласованности транслятора со стандартом языка программирования) - выбор адекватного метода ее проверки, а также создание инструментария для применения этого метода.

Широкое распространение получают стандарты языков программирования с развитым статическим компонентом (или иначе, набором статически проверяемых ограничений). Многие дефекты современных трансляторов для таких языков связаны с неправильным диагностированием ошибок в программах. Как показывает практика контроля языковых стандартов, тестированию диагностики трансляторов не уделяется должного внимания. Однако ущерб от отсутствия диагностики того или иного нарушения стандарта может оказаться катастрофическим. Особенно это верно для больших программных комплексов, к которым предъявляется требование повышенной надежности.

Исследование, проведенное Национальным институтом стандартов и технологии США, показало, что размер убытков, связанных со сбоями в программном обеспечении, можно уменьшить примерно на треть, если вложить дополнительные усилия в инфраструктуру тестирования, в частности, в разработку инструментов тестирования.

Практическая ценность данной работы создать тест-программы проверяющие соответствие стандарта ИСО 9899 1999 и компилятора.

2. Постановка задачи.

Темой данной работы является разработка механизмов тестирования компиляторов языка программирования Си на соответствие стандарту ANSI ISO/IEC 9899:1999 в части декларативных операторов. На рис. 1 показана постановка задачи. Для решения ее с начала переводится стандарт с английского языка, потом анализируется, и пишутся тест-программы. После запуска и отладки результаты заносятся в таблицу. Принимается решение о соответствии компилятора стандарту.

3. Общие принципы тестирование программ

В данном разделе содержится некоторая терминология, относящаяся к тестированию программ (в частности компилятора), и приводится краткий обзор процесса тестирования.

Практически каждая работа, посвященная технологии программирования или надежности программного обеспечения, так или иначе, касается проблем тестирования. Имеется также некоторое количество монографий, посвященных исключительно тестированию. Подавляющая часть работ по тестированию, опубликованных как в нашей стране, так и за рубежом, находится под большим влиянием, или в той или иной степени основывается на фундаментальных трудах Г.Майерса “Надежность программного обеспечения” и “Искусство тестирования программ”.

3.1 Основные определения

Компиляторы составляют существенную часть программного обеспечения ЭВМ. Это связано с тем, что языки высокого уровня стали основным средством разработки программ. Только очень незначительная часть программного обеспечения, требующая особой эффективности, программируется с помощью ассемблеров.

«Тестирование — процесс, подтверждающий правильность програм­мы и демонстрирующий, что ошибок в программе нет.» Основной недостаток подобного определения заключается в том, что оно совершенно неправильно, невозможно продемонст­рировать полное отсутствие ошибок в программе. Поэтому определение описывает невыполнимую задачу, а так как тестирование зачастую все же выполняется с успехом, по крайней мере, с некоторым успехом, то такое определение логически некорректно. Исходя, из этого сформулируем правильное определение тестирования:

Тестирование — процесс выполнения программы с целью обнаружения ошибок.

Невозможно гарантировать отсутствие ошибок в нетривиальной программе; в лучшем случае можно попытаться показать наличие ошибок. Если программа правильно ведет себя для солидного набора тестов, нет основании утверждать, что в ней нет ошибок; со всей определенностью можно лишь утверждать, что не известно, когда эта программа не работает. Конечно, если есть причины считать данный набор тестов способным с большой вероятностью обнаружить все возможные ошибки, то можно говорить о некотором уровне уверенности в правильности программы, устанавливаемом этими тестами.

Вот еще одно научное определение:

Тестирование - это наиболее популярный прием верификации программ, то есть процесса определения степени их правильности. Основной целью верификации является попытка ответить на следующий вопрос: “Правильно ли программа P (называемая объектом верификации) реализует модель M?” Этот вопрос называется условием верификации (verification requirement). Отличие тестирования от других приемов верификации заключается в том, что для ответа на этот вопрос при тестировании действуют от обратного, а именно, пытаются найти контрпримеры, позволяющие ответить на этот вопрос отрицательно.

Тестовым случаем, или тестом (test case), называется набор входных данных, на которых программа исполняется в процессе тестирования. Комплектом тестов, или набором тестов (test set) называется набор тестовых случаев. После исполнения программы на одном из тестов, полученные результаты сравниваются с теми, которые предсказываются моделью. Подсистема, выполняющая это сравнение, независимо от того, выполняется ли оно программой или человеком, называется оракулом (oracle). Майерс под тестом понимает набор входных и ожидаемых выходных данных.

Например, в Std IEEE 829—1983 «Документация тестов программного обеспечения» (США) дано следующее определение тестирования: «...процесс активного анализа ПО на предмет обнаружения расхождения между реаль­ными и требуемыми нормами ПО (т. е. наличия ошибок в про­граммах) и с целью оценки характеристик элементов ПО».

Программа – это упорядоченная последовательность действий для ЭВМ, выполнение которых реализует алгоритм решения какой-либо задачи.

Транслятор (или компилятор) – это программа перевода текста программ с одного языка программирования на другой. Чаще всего транслятор переводит программу на машинный код.

Вместе с тем, команды исходного языка значительно отличаются по организации и мощности от команд машинного языка. Существуют языки, в которых одна команда исходного языка транслируется в 7-10 машинных команд. Однако есть и такие языки, в которых каждой команде может соответствовать 100 и более машинных команд (например, Пролог). Кроме того, в исходных языках достаточно часто используется строгая типизация данных, осуществляемая через их предварительное описание. Программирование может опираться не на кодирование алгоритма, а на тщательное обдумывание структур данных или классов. Процесс трансляции с таких языков обычно называется компиляцией, а исходные языки обычно относятся к языкам программирования высокого уровня (или высокоуровневым языкам). Абстрагирование языка программирования от системы команд компьютера привело к независимому созданию самых разнообразных языков, ориентированных на решение конкретных задач. Появились языки для научных расчетов, экономических расчетов, доступа к базам данных и другие.

Небезопасный код (Unsafe code) – код, в котором позволено выполнять операции низкого уровня, такие как объявление и манипулирование с указателями, преобразования между указателями и интегральными типами, взятие адреса переменной. Такие операции предоставляют такие возможности, как обращение к внутренностям операционной системы, доступ к устройствам памяти или реализацию алгоритмов, очень критичных по времени исполнения.

Предупреждение во время компиляции (Warning, compile-time) - информационное сообщение, появляющееся во время трансляции программы, которое указывает на потенциально сомнительное использование программной конструкции.

Диагностическое сообщение (Diagnostic message) – сообщение, принадлежащее к определенному реализаций подмножеству выходных сообщений.

Ошибка компиляции (Error, compile-time) – ошибка, возникающая во время трансляции программы.

Контроль (verification) — попытка найти ошибки, выполняя программу в тестовой, или моделируемой, среде.

Испытание (validation) — попытка найти ошибки, выполняя программу в заданной реальной среде. Основными видами испытания являются предварительные, приемочные и эксплуатационные испытания, включая опытную эксплуатацию.

Аттестация (certification) — авторитетное подтверждение правильности программы. При тестировании с целью аттестации выполняется сравнение с некоторым заранее определенным стандартом.

Отладка (debugging) не является разновидностью тестирования. Хотя слова «отладка» и «тестирование» часто используются как синонимы, под ними подразумеваются разные виды деятельности. Отладка состоит из нахождения ошибок и их исправления. Первая часть обычно занимает до 90% времени и усилий. (Отладка = Тестирование + Поиск ошибок + Редактирование.)

Тестирование — деятельность, направленная на обнаружение оши­бок; отладка направлена на установление точной природы извест­ной ошибки, а затем — на исправление этой ошибки. Эти два вида деятельности связаны — результаты тестирования являются ис­ходными данными для отладки.

Тестирование приемлемости (acceptance testing) — проверка со­ответствия программы требованиям пользователя.

Тестирование настройки (installation testing) — проверка соот­ветствия каждого конкретного варианта установки системы с целью выявить любые ошибки, возникшие в процессе настройки си­стемы.

Взаимосвязь между этими типами тестов и проектной документа­цией, на которой основывается тест, показана на рис.2.

Рис. 2. Процессы тестирования и их связь с процессами проектирования.

Надежность невозможно внести в программу в результате тестирования, она определяется правильностью этапов проектирования. Наилучшее решение проблемы надежности — с самого начала не допускать ошибок в программе. Однако вероятность того, что удастся безупречно спроектировать большую программу, бесконечно мала. Роль тестирования состоит как раз в том, чтобы определить местонахождение немногочисленных ошибок, оставшихся в хорошо спроектированной программе. Попытки с помощью тестирования достичь надежности плохо спроектированной программы совершенно бесплодны.

Тестирование оказывается довольно необычным процессом (вот почему оно и считается трудным), так как этот процесс разрушительный. Ведь цель проверяющего— заставить программу сбиться.

3.2 Критерий полноты

Проверить выполнение условия верификации в общем случае невозможно. Уже в середине 70-х, Гуденаф и Герхарт отмечали, что центральной задачей является обнаружение критерия тестирования, т.е. критерия, определяющего, какое предположение о свойствах или логике программы будет подвергаться тестированию. В результате, условие верификации выражается следующим образом: “Насколько хорошо программа Р реализует модель М в соответствии с критерием С?”

Критерий тестирования является важной частью любого подхода к тестированию. Существует два вида критериев тестирования: критерии корректности и гипотезы о сбоях. Целью критериев корректности является демонстрация того, что программа удовлетворяет своей модели (т.е. корректна), в то время как гипотезы о сбоях пытаются показать, что в программе отсутствует конкретный класс сбоев.

В соответствии с выбранным критерием тестирования определяется критерий полноты набора тестов, т.е. какими свойствами должен обладать тестовый набор, который удовлетворяет критерию тестирования. Он также называется критерием выборки комплекта тестов из (потенциально бесконечного) множества тестовых случаев.

Выбор тестовых случаев в соответствии с критерием корректности должен включать тестовые случаи, проверяющие существенные свойства модели, и быть достаточно представительным, чтобы обеспечить уверенность в том, что программа реализует свою модель. Для критериев тестирования-гипотез о сбоях необходим тестовый набор, который в состоянии вызвать конкретные классы сбоев.

Нередко критерий полноты определяется как некоторая выборка из множества входных значений программы с целью ее проверки на примечательных случаях.

С чего же начинается тестирование? Для его проведения необходимы объект тестирования - в данном случае компилятор языка программирования С (в общем случаи программное обеспечение) - и эталон, с которым этот объект сравнивается, в данном случаи стандарт ИСО 9899:1999. ПО - это сложный объект, который меняется по составу и проверяемым свойствам на разных стадиях разработки. Важно понимать, что если разработчик и заказчик не сформулировали требования к ПО еще до начала его разработки, то, во-первых, заказчик вряд ли получит именно то, что хотел, и, во-вторых, ПО, которое он все-таки получит, нельзя будет проверить, поскольку объект есть, а эталона нет.

Людям свойственно ошибаться при любом виде деятельности, в том числе и при создании программ. Конечно, эти ошибки неумышленные и человек, в конце концов, их исправит, но как говорят, программ без ошибок не бывает, и на некотором этапе тестирования возникает вопрос, стоит ли дальше искать ошибки или смириться с их некоторым количеством до поры до времени. Этот вопрос подводит нас к определению критериев, по которым можно судить, что программа более или менее работоспособна.

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

Целью является построения множества тестов, характеризующегося наивысшей вероятностью обнаружения большинства ошибок в тестируемой программе, то тест из этого множества должен:
1) уменьшать (более чем на единицу) число других тестов, которые должны быть разработаны для достижения заранее поставленной цели “удовлетворительного” тестирования;
2) покрывать собой значительную часть других возможных тестов.
Другими словами:
1) каждый тест должен заключать в себе проверку наибольшего числа задаваемых внешней спецификацией входных условии (ограничений на входные данные) для того, чтобы минимизировать общее число необходимых тестов;
2) необходимо разбить область значений входных данных на конечное число подобластей (которые будут называться классами эквивалентности), чтобы можно было полагать каждый тест, являющийся представителем некоторого класса, эквивалентным любому другому тесту этого класса (т.е. обнаруживающим одни и те же ошибки).

Наиболее эффективный метод отладки может быть сформулирован так:

• Сбор данных через повторяемые эксперименты

• Создание гипотезы, отражающей максимум доступных данных

• Разработка эксперимента для проверки гипотезы

• Подтверждение или опровержение гипотезы

• При необходимости - итерация предыдущих шагов

3.3 Соотношение качества программы и времени разработки

Важнейшим критерием ПО является соотношение качества и времени разработки. Ошибки бывают разные, и время на их поиск будет различно. От простых опечаток, которые находятся в первый же запуск программы, до неявных ошибок алгоритма или неправильного использования языковых конструкций, на поиск которых можно потратить не только часы, а дни. Последние найти особенно тяжело.

После того как ПО разработано (написан код программы) он должно быть протестировано. (Рис. 3)

Рис. 3. Этап тестирования.

Тестировать надо начинать, когда большая часть функционала программы написана. (Рис. 4)

Рис. 4 Время начала тестирования.

На графике (рис. 5) показано процесс выявления ошибок в течение жизненного цикла ПО.

Рис. 5 График обнаружения ошибок на стадиях разработки

Интуитивно кажется, что чем больше времени затрачивается на разработку, тестирование и отладку, тем лучше качество получаемой программы. Однако оказывается, что существует точка оптимального соотношения "цена/качество" программы (рис. 6)

Получается, что проекты с небольшим количеством допустимых ошибок также являются проектами с минимальным временем выполнения. Проекты, в которых ошибок больше минимально допустимого, тратят много времени на доводку продукта (причем стоимость исправления ошибок в таких проектах выше). Итак, существует некоторое оптимальное качество программного обеспечения. Оно соответствует исправлению ~95% найденных ошибок.

Точка 95% представляет собой достижение уровня, на котором большинство проектов:

• достигает минимального времени выполнения

• затрачивает минимальные усилия

• достигает приемлемого качества продукта

Таким образом, можно сформулировать первый критерий управления качеством: если после выпуска продукта обнаруживается более 5% ошибок, то вашу организацию преследуют проблемы, связанные с качеством, и, кроме того, с большой вероятностью вы тратите больше времени на разработку продукта, чем это необходимо.

Нахождение и исправление "почти всех" ошибок – трудоемкий и дорогостоящий процесс. "Абсолютное качество" имеет смысл только для проектов с повышенными требованиями к надежности ПО (mission-critical software). Актуально в таких областях, как системы управления и контроля, аэрокосмические приложения и т.п.

Когда необходимо заканчивать тестирование программы? Не представляется возможным определить, является ли найденная ошибка последней. Тем не менее, тестирование придется завершать, хотя бы по экономическим соображениям. Этот вопрос можно решать:

• либо волевым способом (решение руководителя), что, очевидно, не ведет к улучшению качества продукта

• либо с помощью некоторого критерия завершения тестирования

Неудачные критерии завершения тестирования являются:

• истечение времени, отведенного на тестирование

• все тесты выполняются без выявления ошибок

Оба критерия никуда не годятся:

• Первый критерий может быть выполнен без каких-либо действий (т.е. он не содержит оценки качества тестирования)

• Второй не имеет смысла, поскольку не зависит от качества тестов и, следовательно, подсознательно побуждает к построению тестов с низкой вероятностью обнаружения ошибки. Люди всегда ориентируются на поставленную цель, и, значит, тестеры, скорее всего, будут писать неудачные тесты

Полезные критерии окончания тестирования все-таки существуют:

• График ошибок (рис. 7)

• Статистика затрат на исправление ошибок

• Методика подсадки ошибок

• Методика тестирования двумя группами

Все эти методы основаны на статистических предсказаниях количества неисправленных (или даже ненайденных!) ошибок.

Рис. 7. График ошибок.

На сегодня соотношение времени, затраченного на проектирование, кодирование и тестирование составляет 40%,20% и 40% соответственно.

3.4 Адекватность

Мерой качества тестового набора является его адекватность критерию полноты, для измерения которой необходимы специальные приемы. Как правило, адекватность выражается как функция покрытия критерия выборки тестовым набором, но также может быть функцией гипотез, предполагаемых о программе.

Современная литература по тестированию содержит два различных, хотя и близко связанных, понятия, относящихся к термину “критерий адекватности тестовых данных”. Во-первых, критерий адекватности считается “стоп-правилом”, определяющим, когда был уже получен достаточно представительный комплект тестов и его пополнение может быть прекращено. Во-вторых, критерий адекватности предоставляет возможность оценки степени адекватности данного тестового набора, а именно, каждому набору сопоставляется некоторое вещественное число из отрезка [0, 1], называемое степенью адекватности. Легко видеть, почему эти два понятия тесно связаны: с одной стороны, стоп-правило – это, фактически, отображение множества наборов тестов во множество {0, 1}, где 0 означает, что тестовый набор недостаточен, а 1 – что он адекватен. С другой стороны, для любой меры адекватности M и любой степени адекватности r можно предложить стоп-правило M_r такое, что тестовый набор считается адекватным, если мера его адекватности не ниже r.

Критерии адекватности чрезвычайно важны для любого метода тестирования. Они играют две фундаментальные роли.

Во-первых, критерий адекватности определяет, какие тестовые случаи должны добавляться к комплекту тестов для улучшения удовлетворения им критерия тестирования. Это свойство критерия адекватности может иметь форму явной спецификации для выборки тестовых случаев, и называться критерием выборки тестовых случаев (при этом подход к тестированию определяется конструктивно, как алгоритм, генерирующий комплект тестов на базе тестируемого ПО и собственной спецификации). Оно также может иметь форму описания способа оценки адекватности данного набора тестов, и тогда он называется критерием адекватности тестовых наборов. Т.е. критерий адекватности может использоваться не только с целью генерации набора тестов, но и с целью определения адекватности уже существующего набора тестов.

Второй ролью критерия адекватности является определение набора наблюдений, которые должны быть проведены в процессе прогонки комплекта тестов. Например, при тестировании покрытия путей вычислений, должны быть определены и зарегистрированы все возможные пути в программе.

3.5 Классификация подходов к тестированию

Существуют разные способы классификации подходов к тестированию. Один из самых распространенных – классификация по источнику информации, используемой для формулирования требований к процессу тестирования и измерения адекватности. По источнику информации различают два подхода к тестированию черного и белого ящика.

3.5.1 Тестирование по методу “черного ящика”

Тестирование по методу “черного ящика” (black-box testing), называемое также функциональным тестированием, рассматривает программу как единую сущность, “черный ящик”, свойства которого заданы его описанием (спецификацией) и не предполагает никакого знания о внутренних деталях реализации, схема изображена на рис. 8. Целью такого тестирования является обнаружение несоответствия реального поведения программы ее описанию.

Черный ящик F(x,y)Рис. 8. Тестирования по методу «Черного ящика»Входные данные(x,y)Выходные данныеz=F(x,y)

К тестированию по методу “черного ящика” относятся такие критерии адекватности:

• Критерии на базе формальной спецификации, то есть задания множеств входных и выходных данных и прочих “внешних” свойств программы при помощи формальных языков. Адекватность при этом можно, например, измерять по покрытию аксиом спецификации.

• Критерии на базе полуформальной спецификации, то есть сочетания формализованных описаний внешних свойств программы с неформальными, апеллирующими к житейскому и профессиональному опыту программиста и изложенными простым разговорным языком. Именно такие спецификации описывают абсолютно подавляющее большинство реальных программных продуктов.

• Критерии на базе интерфейса, определяющие условия тестирования только исходя из типа и диапазона входных значений и не учитывающие внутренние свойства спецификации (формальной или неформальной). Адекватность нередко измеряют при этом по покрытию множества входных значений после их разбиения на некоторые классы эквивалентности.

Пример: Рассмотрим по­пытку тестирования тривиальной программы, получающей на входе три числа и вычисляющей их среднее арифметическое. Тестирова­ние этой программы для всех значений входных данных невозмож­но. Даже для машины с относительно низкой точностью вычислений количество тестов исчислялось бы миллиардами. Для выполнения всех тес­тов в разумное время, мы потратили бы на несколько порядков больше времени для того, чтобы эти тесты подготовить, а затем проверить. Нам потребуется тестировать программу не только для каждого входного значения, но и для каждой комбинации входных данных. Поэтому исчерпывающее тестирование для всех входных данных любой разумной программы неосущест­вимо. Поэтому можно говорить только о конкретных конечных значениях и ограниченного числа тестов.

3.5.2 Тестирование по методу “белого ящика”

Тестирование по методу “белого ящика” (white-box testing), когда существует доступ к деталям внутренней реализации тестируемой программы, и тестирование производится исходя из этой добавочной информации.

К тестированию по методу “белого ящика” относятся:

• Критерии на базе структуры программы, включающие разные способы оценки полноты тестирования внутренней структуры, такие как доля вызванных подпрограмм, выполненных инструкций, или затронутых простых ветвей управления.

Рис. 9. Тестирования по методу «Белого ящика»Изучение внутренних алгоритмов работы ПО, структуры, разбивка по алгоритмам (1, 2, 3, ...)Написание тест-программы внутренних алгоритмовПолучение и анализ результата

Тестирование по методу “белого ящика” обеспечивает рис. 9, вообще говоря, более высокое качество тестирования, однако не гарантирует полноту проверки внешнего эффекта (реализуемой функции). Метод “черного ящика” более соответствует потребностям пользователя программы, которого интересует не внутреннее устройство программы, а реализуемая ей функция, в нашем случаи внутренней структуры компилятора. Кроме того, существуют значительные препятствия для использования метода “белого ящика” для целей внешнего тестирования программ, из-за того, что тексты реализации программы, как правило, недоступны или необозримы. Кроме того, весь процесс разработки системы тестирования вырождается в этом случае в разработку индивидуального набора тестов для каждой реализации программы и даже для каждой новой версии данной реализации, что не имеет смысла в случае внешнего тестирования реализаций на соответствие стандарту.

Смешанные методы, сочетающие программный подход и спецификацию.

Так как нашей целью является предложить универсальный подход к тестированию реализаций компилятора С в области декларативных операторов, то подход на базе “белого ящика” нам непригоден. Будем поэтому в дальнейшем под словом “тестирование” всегда понимать исключительно тестирование по методу “черного ящика”.

Пример: Вернемся, к примеру, рассмотренному выше. Для того чтобы не пришлось бы перебирать всевозможные значения, можно тестировать лишь сам алгоритм работы программы, изучив принципы его работы.

3.5.3 Модельное тестирование

В голове разработчика и тестировщика всегда присутствует та или иная «модель» устройства программы, а также «модель» ее желаемого поведения, исходя из которой, в частности, составляются списки проверяемых свойств и создаются соответствующие тестовые примеры. (Заметим, что это разные модели; первые часто называют архитектурными, а вторые — функциональными или поведенческими.) Они зачастую составляются на основе документов или обсуждений в неформальном виде.

Разработка моделей и спецификаций связана с «математизацией» программирования. Попытки использовать различные математические подходы для конструирования и даже генерации программ предпринимались с первых лет возникновения компьютеров. Относительный успех был, достигнут в теории компиляторов, реляционных баз данных и в нескольких узкоспециальных областях; серьезных результатов в большинстве практических областей достичь не удалось. Многие стали относиться к формальным методам в программировании скептически.

Преимущества тестирования на основе моделей виделись в том, что:

• тесты на основе спецификации функциональных требований более эффективны, так как они в большей степени нацелены на проверку функциональности, чем тесты, построенные только на знании реализации;

• на основе формальных спецификаций можно создавать самопроверяющие (self-checking) тесты, так как из формальных спецификаций часто можно извлечь критерии проверки результатов целевой системы.

Однако не было ясности в отношении качества подобных тестов. Модели обычно проще реализации, поэтому можно было предположить, что тесты, хорошо «покрывающие» модель, слишком бедны для покрытия реальных систем. Требовались широкие эксперименты в реальных проектах.

Модель — некоторое отражение структуры и поведения системы. Модель может описываться в терминах состояния системы, входных воздействий на нее, конечных состояний, потоков данных и потоков управления, возвращаемых системой результатов и т.д. Для отражения разных аспектов системы применяются и различные наборы терминов. Формальная спецификация представляет собой законченное описание модели системы и требований к ее поведению в терминах того или иного формального метода.

Тестирование по методу модельного тестирования изображено на рис. 10.

Рис. 10. Модельное тестированиеРазработка модели(ей) ПО, которое наиболее просто будет проверитьНаписание тестов проверки моделиПолучения и анализ результата

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

3.5.4 Модульное тестирование

Модульному тестированию подвергаются небольшие модули (процедуры, классы и т.п.). При тестировании относительного небольшого модуля размером 100-1000 строк есть возможность проверить, если не все, то, по крайней мере, многие логические ветви в реализации, разные пути в графе зависимости данных, граничные значения параметров. В соответствии с этим строятся критерии тестового покрытия (покрыты все операторы, все логические ветви, все граничные точки и т.п.).

Минусы этого метода очевидны успешно пройденные тесты не гарантирую работу системы в целом.

Способы тестирования взаимодействия модулей.

Существуют два способа проверки взаимодействия модулей:

·         Монолитное тестирование

·         Пошаговое тестирование

 Пусть имеется программа, состоящая из нескольких модулей рис. 11.

ABCDFGHEIJРис. 11. Модульный состав программы

Прямоугольники – модули, тонкие линии представляют иерархию управления (связи по управлению между модулями), жирные стрелки – ввод и вывод данных в программу.

Монолитное тестирование заключается в том, что каждый модуль тестируется отдельно. Для каждого модуля пишется один модуль драйвер, который передает тестируемому модулю управление, и один или несколько модулей-заглушек рис. 12. Этот метод схож с методом «Большого скачка», который будет рассмотрен ниже.

Например, для модуля B нужны 2 заглушки, имитирующие работу модулей Е и F.

Когда все модули протестированы, они собираются вместе и тестируется вся программа в целом.

AД.ВBЗ.CД.DРис. 12. Монолитное тестированиеABCDFGHEIJД.FД.IЗ.HД.JЗ.E

Модуль-драйвер - используется для передачи тестируемому модулю входных тестовых данных и возврата результата тестирования. (Д)
Модуль - заглушка - используется для имитации работы процедур и функций тестируемого модуля. (З)

Модуль заглушку написать сложнее, чем модуль драйвер.

Пошаговое тестирование предполагает, что модули тестируются не изолированно, а подключаются поочередно к набору уже оттестированных модулей.

Недостатки монолитного тестирования (перед пошаговым):

1.        Нужно много дополнительных действий (написание драйверов и заглушек)

2.        Поздно обнаруживаются ошибки в межмодульных взаимодействий

3.        Следствие из 2 – труднее отлаживать программу

Преимущества

1.        Экономия машинного времени (в настоящее время существенной экономии не наблюдается)

2.        Возможность параллельной организации работ на начальной фазе тестирования.

Существую две принципиально различных стратегии выполнения пошагового тестирования:

восходящие и нисходящем тестирование. Рассмотрим их ниже.

1. Восходящие тестирование

При восходящем подходе программа собирается и тестируется снизу вверх. Только модули самого нижнего уровня («терминаль­ные» модули; модули, не вызывающие других модулей) тестируются изолированно, автономно. После того как тестирование этих модулей завершено, вызов их должен быть так же надежен, как вызов встроенной функции языка или оператор присваивания. Затем тес­тируются модули, непосредственно вызывающие уже проверенные. Эти модули более высокого уровня тестируются не автономно, а вместе с уже проверенными модулями более низкого уровня. Про­цесс повторяется до тех пор, пока не будет достигнута вершина. Здесь завершаются и тестирование модулей, и тестирование сопря­жении программы.

При восходящем тестировании для каждого модуля необходим драйвер: нужно подавать тесты в соответствии с сопряжением те­стируемого модуля. Одно из возможных решении — написать для каждого модуля небольшую ведущую программу. Тестовые данные представляются как «встроенные» непосредственно в эту программу переменные и структуры данных, и она многократно вызывает тес­тируемый модуль, с каждым вызовом передавая ему новые тестовые данные. Имеется и лучшее решение: воспользоваться программой тестирования модулей — это инструмент тестирования, позволяю­щий описывать тесты на специальном языке и избавляющий от необходимости писать драйверы.

Предполагает начало тестирования с модулей (не вызывающих других). Таким образом, очередной тестируемый модуль может вызывать только ранее оттестированный модуль, для каждого последующего модуля следует написать модуль-драйвер. Вначале начале тестируется модуль С, потом F рис. 13.

Рис. 13. Восходящие тестированиеД.AД.BCFД.AД.BCDFABCDFH

1. Нисходящие тестирование.

Нисходящее тестирование называемое также нисходящей раз­работкой не является полной противоположностью восходя­щему, но в первом приближении может рассматриваться как тако­вое, При нисходящем подходе программа собирается и тестируется сверху вниз. Изолировано тестируется только головной модуль. После того как тестирование этого модуля завершено, с ним соеди­няются (например, редактором связей) один за другим модули, непосредственно вызываемые им, и тестируется полученная комби­нация. Процесс повторяется до тех пор, пока не будут собраны и проверены все модули.

При этом подходе немедленно возникает вопрос: что де­лать, когда тестируемый модуль вызывает модуль более низкого уровня (которого в данный момент еще не существует), и как подаются тестовые данные. Ответ на первый вопрос состоит в том, что для имитации функций недостающих модулей программируются модули-заглушки», которые моделируют функции отсутствующих модулей. Фраза «просто напишите заглушку» часто встречается в описании этого подхода, но она способна ввести в заблуждение, поскольку задача написания заглушки» может оказаться трудной. Ведь заглушка редко сводится просто к оператору RETURN, поскольку вызывающий модуль обычно ожидает от нее выходных параметров. В таких случаях в заглушку встраивают фиксирован­ные выходные данные, которые она всегда и возвращает. Это иногда оказывается неприемлемым, так как вызывающий модуль может рассчитывать, что результат вызова зависит от входных данных. Поэтому в некоторых случаях заглушка должна быть довольно изощ­ренной, приближаясь по сложности к модулю, который она пытается моделировать.

Например, на рис. . начинается с головного модуля, в нашем случае с модуля А. Возникают проблема: как передать тестовые данные в А, ведь ввод и вывод осуществляется в других модулях? Как передать в А несколько тестов?

Решение:

а) Написать несколько вариантов заглушек B, для каждого теста

б) Написать заглушку B так, чтобы она читала тестовые данные из внешнего файла.

Стратегии подключения модулей:

а) подключаются наиболее важные с точки зрения тестирования модули

б) подключаются модули, осуществляющие операции ввода/вывода (для того, чтобы обеспечивать тестовыми данными «внутренние» модули.

Однако нисходящее тестирование, в данном случаи, имеет ряд недостатков:

Предположим, что модули I и J уже подключены, и на следующем шаге тестирования заглушка H меняется на реальный модуль H.

Как передать тестовые данные в Н?

Это нетривиальная задача, потому что между J и Н имеются промежуточные модули и может оказаться невозможным передать тестовые данные, соответствующие разработанным тестам. К тому же достаточно сложно интерпретировать результаты тестирования Н, так как между Н и I также существуют промежуточные модули.

Можно продемонстрировать и на другой, более простом примере на рис. 14.

Рис. 14. Низходящие тестированиеABCDFHABЗ.CЗ.DЗ.FAЗ.BЗ.C З.D

Нисходящий метод имеет как достоинства, так и недостатки по сравнению с восходящим. Самое значительное достоинство — в том, что этот метод совмещает тестирование модуля, тестирова­ние сопряжении и частично тестирование внешних функций. С этим же связано другое его достоинство — когда модули ввода-вывода уже подключены, тесты можно готовить в удобном виде. Нисходя­щий подход выгоден также в том случае, когда есть сомнения от­носительно осуществимости программы в целом или если в проек­те программы могут оказаться серьезные дефекты.

Преимуществом нисходящего подхода очень часто считают от­сутствие необходимости в драйверах; вместо драйверов вам просто следует написать «заглушки». Как читатель сейчас уже, вероятно, понимает, это преимущество спорно.

Нисходящий метод тестирования имеет, к сожалению, некоторые недостатки. Основным из них является тот, что модуль редко тес­тируется досконально сразу после его подключения. Дело в том, что основательное тестирование некоторых модулей может потре­бовать крайне изощренных заглушек. Программист часто решает не тратить массу времени на их программирование, а вместо этого пишет простые заглушки и проверяет лишь часть условий в модуле. Он, конечно, собирается вернуться и закончить тестирование рас­сматриваемого модуля позже, когда уберет заглушки. Такой план тестирования определенно не лучшее решение, поскольку об от­ложенных условиях часто забывают.

Второй тонкий недостаток нисходящего подхода состоит в том, что он может породить веру в возможность начать программирова­ние и тестирование верхнего уровня программы до того, как вся программа будет полностью спроектирована. Эта идея на первый взгляд кажется экономичной, но обычно дело обстоит совсем наобо­рот. Большинство опытных проектировщиков признает, что проекти­рование программы — процесс итеративный. Редко первый проект оказывается совершенным. Нормальный стиль проектирования структуры программы предполагает по окончании проектирования нижних уровней вернуться назад и подправить верхний уровень, внеся в него некоторые усовершенствования или исправляя ошибки, либо иногда даже выбросить проект и начать все сначала, потому что разработчик внезапно увидел лучший подход. Если же головная часть программы уже запрограммирована и оттестирована, то воз­никает серьезное сопротивление любым улучшениям ее структуры. В конечном итоге за счет таких улучшений обычно можно сэконо­мить больше, чем те несколько дней или недель, которые рассчиты­вает выиграть проектировщик, приступая к программированию слишком рано.

1. Метод большого скачка

Вероятно, самый распространенный подход к интеграции мо­дулей — метод «большого скачка». В соответствии с этим методом каждый модуль тестируется автономно. По окончании тестирования модулей они интегрируются в систему все сразу.

Метод большого скачка по сравнению с другими подходами име­ет много недостатков и мало достоинств. Заглушки и драйверы не­обходимы для каждого модуля. Модули не интегрируются до самого последнего момента, а это означает, что в течение долгого времени серьезные ошибки в сопряжениях могут остаться необнаруженными. Метод большого скачка значительно усложняет отладку. Проверка корректности всех модулей, к сожалению, не гарантирует корректности функционирования системы модулей.

И все же большой скачок не всегда нежелателен. Если програм­ма мала и хорошо спроек­тирована, он может оказаться приемлемым. Однако для крупных программ метод большого скачка обычно губителен.

1. Метод сэндвича.

Тестирование методом сэндвича представляет собой компромисс между восходящим и нисходящим подходами. При использовании этого метода одновременно начинают восходящее и нисходящее тестирование, собирая программу как снизу, так и сверху и встречаясь, в конце концов, где-то в середине. Точка встречи зависит от конкретной тестируемой программы и должна быть заранее определена при изучении ее структуры. Если разработчик может представить свою систему в виде уровня прикладных модулей, затем уровня модулей обработки запросов, затем уровня примитивных функций, то он может решить применять нисходящий метод на уровне прикладных модулей, а на остальных уровнях применить восходящий метод.

3.5.8 Описание тестирования согласно стандарту IEEE STD 829

Стандарт IEEE 829 Software Test Documentation – “задает планку” для индустрии ИТ (информационные технологии) по организации документирования процесса тестирования. Этот стандарт разрабатывался с 1977 года и был утвержден в 1983 году, а затем вновь подтвержден в 1991 и 1998 годах. Место и роль процесса тестирования в жизненном цикле разработки и сопровождения ПО описаны во многих стандартах, в том числе и в стандарте ГОСТ Р ИСО/МЭК 12207.

На всех этапах тестировании могут быть разные исполнители в рамках одного проекта, различная структура процессов, но перечень документов должен сохраняется. Состав документов, рекомендованных в стандарте IEEE STD 829 (рис. 15): план тестирования, проект теста, спецификация тестового сценария, спецификация тестовой процедуры, отчет о ходе тестирования, протокол тестирования, отчет о найденных ошибках, итоговый отчет о тестировании.

Проект теста: название, перечень тестируемых свойств системы, уточнение подхода к тестированию, описание теста, критерии успеха/неудачи тестов.

Спецификация сценария теста: название, тестируемые элементы, спецификация входных и выходных данных, необходимая среда тестирования, специальные требования к процедуре, взаимосвязи.

Спецификация тестовой процедуры: название, цель, специальные требования, шаги выполнения процедуры.

Рис. 15. Рабочие и выходные документы процесса тестирования.

3.5.9. Автоматизированного тестирования

Тестировать программные приложения становится все труднее, поскольку продолжает расти их техническая и функциональная сложность. К сожалению, технология большинства процессов тестирования не успевает за новыми типами приложений. Возникающее несоответствие подвергает риску качество программ и бюджет проекта - процесс тестирования требует пересмотра. Блок-схема авторизированного тестирования изображена на рис. 16.

Рис. 16. Авторизированное тестирование

Для большинства проектов этот процесс включает тестирование кода приложения с ожидаемыми результатами. Затем разработчики "фиксируют" приложение до тех пор, пока оно не обеспечит нужный результат. Либо происходит корректировка ожидаемого результата, если возникла ошибка. Такой подход фокусируется на коде приложения и его поведении на множестве тестовых условий. Оказывается, что тщательное тестирование приложения требует большого числа тестовых условий. При таком подходе к тестированию предполагается, что качество приложения является функцией от количества тестов - чем больше тестов, тем лучше качество.

Программа должна уметь применять к тестируемым объектам тестируемые методы. Программа должна уметь сравнивать результат выполнения метода с ожиданием(стандартом), и в случае расхождений - максимально подробно описывать эти расхождения. Эта программа должна уметь обрабатывать сразу много тестов в одном пакете.

Такой подход имеет свои плюсы. Основной довод противников автоматического тестирования - "Что произойдет, если ошибка возникнет в программе тестирования?". На первый взгляд - очень веский аргумент. Однако довольно трудно ошибиться в написании программы сравнения одного с другим. Все остальные части программы тестировщика - некритичны к ошибкам.

Однако, есть и минусы. Во-первых, создание тестов - довольно кропотливая работа. Во-вторых, не все ожидания можно описать в пригодном для машины виде. Например практически невозможно описать ожидания от GUI. В-третьих, единичный тест - это всего лишь маленький частный случай. Даже большой набор тестов - просто большой набор маленьких частных случаев. Не надо думать, что если все тесты проходят, то в программе нет ошибок. Невозможно описать все частные случаи, поскольку это займет слишком много времени. Однако, цитируя Мартина Фаулера, "лучше выполнить неполный набор тестов, который выявит большинство ошибок, чем не выполнить никаких тестов вообще".

Что касается технического обеспечения, то здесь, прежде всего, следует отметить систему автоматизированного тестирования AQA, позволяющую нам решать целый ряд вопросов:

• Экономия ресурсов и повышение качества тестирования. Автоматическое тестирование по заданному сценарию не требует участия человека — система сама тестирует программный продукт во всех нужных режимах, ничего не пропуская. Вмешательство человека требуется только для пополнения библиотеки сценариев.

• Стабилизация надежности. Когда в системе проводятся какие-либо изменения, то самые трудноуловимые ошибки — те, что возникают в уже проверенных компонентах. Повторный запуск сценариев тестирования после внесения изменений позволяет обнаружить ошибки в ситуациях, где тестировщик с большой вероятностью мог бы их пропустить. Таким образом, надежность уже отлаженных и проверенных компонентов системы находится под постоянным контролем и не может быть нарушена при внесении изменений в другие компоненты.

• Параллельное тестирование системы на разных платформах. Отлаженные сценарии тестирования могут запускаться на любой из поддерживаемых в данный момент платформ (Oracle, MS SQL).

Все это относится к тестированию новых версий, полный цикл разработки которых занимает длительное время. С одной стороны, основной объем работ перекладывается на систему AQA — никакая команда тестировщиков не сможет за короткое время пройти все модули программы и гарантировать, что изменения не отразились на "старых", многократно проверенных функциях. С другой стороны, новые функции требуют ручного тестирования, одновременно отрабатывается технология их проверки, и создаются сценарии, которые будут в дальнейшем использоваться при автоматизированном тестировании с помощью системы AQA.

Система автоматизированного тестирования теоретически позволяет гарантировать стопроцентное качество системы, необходимо лишь составить исчерпывающую библиотеку сценариев. Традиционно считается, что качество приложения является функцией от количества тестов.

Основные свойства средств автоматизированного тестирования, которыми должна обладать вновь разрабатываемая система автоматизированного тестирования:

• Наличие специального хранилища тестов, позволяющего работать в многопользовательском режиме, и проводить версионный контроль сделанных изменений, так как тесты подвержены частым изменениям.

• Наличие центрального хранилища тестовых ресурсов.

• Наличие системы управления тестовыми ресурсами.

• Наличие системы функционального автономного тестирования, позволяющей тестировать как конвертерную часть, так и графический пользовательский интерфейс

• Наличие средств построения отчетов и количественной оценки качества текущей версии продукта.

• Наличие системы распределения процесса тестирования.

Основные компоненты системы автоматизированного тестирования изображены на рис. 17.

Рис. 17. Основные компоненты системы автоматизированного тестирования

Хранилище тестов предоставляет необходимый набор функций для обеспечения версионного контроля, а также возможности работы в пакетном режиме, что немаловажно для проведения автономного тестирования. К тому же она используется в процессе разработки самого тестируемого продукта

Система управления тестовыми ресурсами должна давать возможность пользователь просматривать список имеющихся наборов параметров, их свойства, создавать свои наборы параметров, также просматривать список существующих тестовых проектов, изменять их свойства, добавлять новые проекты, позволяет легко расширять систему тестирования при появлении новых функциональных черт системы, нуждающихся в автоматизированном тестировании, позволять хранить информацию не только о том, на каких наборах тестов проводится тестирование, но и с какими наборами значений параметров конвертера. Необходима система хранения такого рода информации.

Система тестирования конвертерной части. Весь цикл тестирования разбивается на отдельные шаги. Реализуя каждый его шаг как отдельный модуль, можно добиться возможности переиспользования программного кода системы автоматизированного тестирования, что позволит сэкономить время разработки ее новых частей и облегчит сопровождение уже написанного кода.

GUI – система тестирования графического интерфейса.

Система распределенного тестирования. Для того чтобы быстро и полно протестировать текущую версию выпускаемого продукта, необходимы большие вычислительные ресурсы. Известно, что, зачастую, в организациях по разработке программного обеспечения компьютеры в ночное время никак не используются. Возникла идея использовать эти вычислительные ресурсы, имеющиеся в нашем распоряжении, для проведения автономного тестирования. Появилась задача разработки системы распределения тестовых заданий по компьютерам.

Для организации подобной системы на каждом компьютере, участвующем в процессе распределенного тестирования, запускается независимый процесс, который выполняет следующие задачи:

• сигнализирует о том, что данный компьютер активен и участвует в процессе тестирования;

• отслеживает очередь задач для локального компьютера;

• запускает систему автономного тестирования.

В настоящий момент существует система автоматизированного тестирования RescueWare, которая широко используется для проведения регулярного тестирования и регрессионного тестирования ежесуточных версий продукта, что позволило заметно улучшить качество выпускаемого продукта.

3.5.10. Системное тестирования цикл-тестами

В ходе системного тестирования обнаруживаются, исправляются и проверяются дефекты и несоответствия системы по ходу написания программы рис. 18. Кроме исправлений, никаких изменений в системе не предполагается: функциональность входе тестирования не меняется. Системное тестирование состоит из «прогонов» (тест-раундов) изображено на рис. 19, в каждом из которых тестируется очередная собранная версия системы(build). Системное тестирование завершается, когда система (очередная версия) имеет требуемый уровень качества/готовности (см. п. 3.3)

Уровень готовности (в терминах числа и степени серьёзности дефектов) обычно определяется до начала системного тестирования.

Рис. 18. Циклы тестирования

Рис. 19. Общая схема СТ.

Характеристики цикла тестирования:

К началу тест-цикла завершена реализация промежуточного продукта, он содержит всю функциональность в запланированных рамках; эта функциональность составляет область тестирования.

Дефекты и несоответствия обнаруживаются, исправляются и проверяются в области тестирования. Кроме исправлений, никаких изменений в области тестирования не предполагается.

Тест-цикл даёт «здравые» метрики для определения уровня качества/готовности продукта в области тестирования (тренды обнаружения и исправления дефектов).

Критерии готовности определяются до начала тест-цикла («цели по качеству»). Тест-цикл завершается, когда продукт (очередная версия) имеет требуемый уровень готовности в области тестирования.

В результате выполнения цикла тестирования:

• имеем объект измерений-продукт, взятый в определённый момент разработки.

- «Фиксируем» состояние продукта (baseline); всегда можем собрать его в этом состоянии.

• получаем достоверную информацию о качестве продукта

- в виде совокупности измерений данного объекта

- выполнить эти измерения можно только в формате тест-цикла

• знаем, достигли ли нужного нам на данный момент уровня качества продукта

- мы знаем, в какой мере зафиксированное состояние продукта (подсистема, ядро, функциональный слой) свободно от дефектов (в какой мере достигнуты критерии)

• снижаем риски разработки

- развиваем продукт от достигнутого состояния, делая поправки в зависимости от достигнутого уровня качества.

3.5.11. Новый подход к процессу тестирования

Тестирование должно помочь находить и исправлять ошибки на самой возможной ранней стадии. Пересмотр процесса тестирования включает определение концептуальной структуры, организующей различные технологии тестирования. Среда для этого процесса построена на концепции "стадийной локализации" (stage containment), то есть обнаружении и исправлении ошибок на той стадии, где они и появились.

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

При новом подходе тестирование должно стать более производительным и эффективным. Точно определенные приемы поддерживают процесс эффективного тестирования путем применения надежных методов и уменьшения дублирования между тестами на разных стадиях. Соответствие условий тестирования специфике его стадий, также как и фазам разработки, поддерживает высокое качество тестирования тем, что каждое условие проверяется только один раз. Результатом применения стадийной локализации в процессе тестирования является V-модель, которая определяет структуру мероприятий верификации, утверждения и тестирования на основе спецификаций. Эта структура организует мероприятия разработки - такие, как формальные проверки, обзоры и формальное тестирование.

С помощью подхода V-модель можно точно определить границы применимости и назначения каждого теста по его соответствующей спецификации. Это помогает избежать неэффективности многих приемов тестирования, включая перекрытие тестовых условий и повторное проведение тех же тестов, но на разных уровнях. V-модель содержит три тестирующих действия: верификацию (verification), проверку на корректность (validation) и собственно тестирование (testing).

Верификация

Верификация удостоверяет, что объект работы внутренне непротиворечив и соответствует стандартам. Преимущество верификации состоит в обнаружении ошибок на ранних этапах разработки, до того, как они попадут на следующую стадию. Это уменьшает затраты. Верификация применима ко всем объектам (как к тестовым моделям, так и к спецификациям). Методы верификации включают экспертные оценки, формальный контроль и проверки на непротиворечивость.

Проверка на корректность

Здесь проверяется, удовлетворяет ли объект требованиям, специфицированным на предыдущей и более ранних стадиях. Преимущество проверки на корректность заключается в отлавливании ошибок до того, как они перешли в следующую стадию разработки. Эти методы также применимы ко всем объектам (к тестовым моделям и спецификациям). Используемые здесь приемы могут включать обзоры и формальные проверки, а также прототипирование и моделирование.

Тестирование, основанное на спецификациях

V-модель соотносит стадии тестирования с соответствующими стадиями разработки. Мероприятия тестирования сосредоточены на проверке определенных спецификаций, на каждой стадии разработки. Это уменьшает степень наложения тестов и точно определяет рамки и задачу каждого из них. Проверка на основе спецификаций позволяет отслеживать требования на протяжении всего процесса тестирования и предоставляет основу для управления процессом тестирования. Реализация V-модели и стадийной локализации включает изменение процессов разработки, организации и технологии - своего рода заповеди, следование которым поможет при планировании и последующей реализации проекта. Все вместе эти заповеди позволят относиться к тестированию как к постоянной и построенной на единых принципах деятельности на протяжении всего цикла разработки.

Определение критерии входа и выхода. Критерии входа и выхода определяются для тех моментов, когда стадия начинается и заканчивается. Руководители работ должны определить их во время планирования проекта. Применение критериев улучшает продвижение проекта со стадии на стадию. Выполнение критериев входа и выхода означает, что проект действительно продвигается вперед, а разработчики не просто "заметают" свои ошибки "под ковер" следующей стадии.

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

Управление метриками тестирования. Определенный процесс, с критериями входа и выхода, обеспечивает основу для измерений процесса разработки и тестирования. Множество метрик тестирования дает руководителям проекта достоверную информацию о ходе разработки. Метрики тестирования отслеживают количество ошибок, стадию, на которой они обнаружены, и меры для их устранения. Эта информация позволяет руководителям анализировать продвижение проекта, производительность коллективов и необходимость корректирующих действий. К примеру, ошибки, допущенные во время анализа, но обнаруженные в процессе проектирования, могут служить сигналом о недостаточном понимании функциональности приложения.

Заключение

Функциональная и техническая сложность современных приложений бросает вызов возможностям процессов тестирования, которые традиционно сосредоточены только на тестировании кода. Коллективам разработчиков проектов требуется процесс тестирования, построенный на новых принципах, что и позволит преодолеть эти сложности. Процесс, который мы предлагаем, объединяет мероприятия тестирования на протяжении процесса разработки вместо концентрации усилий на тестировании после того, как код написан. Этот усовершенствованный процесс тестирования предлагает концептуальную структуру для организации различных методов и подходов тестирования, включая обзоры, проверки и формальное тестирование.

3.6 Процесс тестирования

Процесс тестирования обычно состоит из следующих трех этапов:

• Этап выбора тестов, на котором генерируется тестовый набор такой, чтобы удовлетворить требованиям тестирования в соответствии с ранее выбранным критерием выборки. Процедура выбора тестов должна также принять решение о том, каковы ожидаемые значения выбранных тестов.

• Этап выполнения тестов, на котором выполняются все тестовые случаи набора.

• Этап оценки результатов, на котором результаты предыдущего этапа сравниваются с ожидаемыми. Результаты этого сравнения используются для того, чтобы подтвердить, опровергнуть или оставить неопределенным условие верификации. Последний случай имеет место в случае нетривиальной логики реализации теста и оракула, когда выполнение теста не породило результата или оракул не смог выполнить сравнения.

В то время как первый этап является в большинстве случаев независимым, этапы 2 и 3 могут не разделяться, особенно в случае автоматических самопроверяющихся тестов.

У Майерса сформулированы основные принципы организации тестирования :
1) необходимой частью каждого теста должно являться описание ожидаемых результатов работы программы, чтобы можно было быстро выяснить наличие или отсутствие ошибки в ней;
2) следует по возможности избегать тестирования программы ее автором, т.к. кроме уже указанной объективной сложности тестирования для программистов здесь присутствует и тот фактор, что обнаружение недостатков в своей деятельности противоречит человеческой психологии (однако отладка программы эффективнее всего выполняется именно автором программы);
3) по тем же соображениям организация - разработчик программного обеспечения не должна “единолично ” его тестировать (должны существовать организации, специализирующиеся на тестировании программных средств);
4) должны являться правилом доскональное изучение результатов каждого теста, чтобы не пропустить малозаметную на поверхностный взгляд ошибку в программе;
5) необходимо тщательно подбирать тест не только для правильных (предусмотренных) входных данных, но и для неправильных (непредусмотренных);
6) при анализе результатов каждого теста необходимо проверять, не делает ли программа того, что она не должна делать;
7) следует сохранять использованные тесты (для повышения эффективности повторного тестирования программы после ее модификации или установки у заказчика);
8) тестирования не должно планироваться исходя из предположения, что в программе не будут обнаружены ошибки (в частности, следует выделять для тестирования достаточные временные и материальные ресурсы);
9) следует учитывать так называемый “принцип скопления ошибок”: вероятность наличия не обнаруженных ошибок в некоторой части программы прямо пропорциональна числу ошибок, уже обнаруженных в этой части;
10) следует всегда помнить, что тестирование - творческий процесс, а не относиться к нему как к рутинному занятию.

3.7 Философия тестирования

Тестирование декларативных операторов охватывает целый ряд видов деятельности, весьма аналогичный последовательности про­цессов разработки программного обеспечения. Сюда входят поста­новка задачи для теста, проектирование, написание тестов, тести­рование тестов и, наконец, выполнение тестов, и изучение результа­тов тестирования. Решающую роль играет проектирование теста. Возможен целый спектр подходов к выработке философии, или стратегии проектирования тестов. Чтобы ориентироваться в стратегиях проектирования тестов, стоит рассмотреть два крайних подхода, находящихся на границах спек­тра, изображенный на рис. 20.

Типы тестирования:

1. Тестирование по отношению к спецификациями (не заботясь о тексте программы)

2. Тестирование по отношению к тексту программы (не заботясь о спецификациях)

3. Возможные комбинации.

Рис. 20. Спектр подходов к проектированию тестов

Оптимальная стратегия проектирования тестов расположена внутри интервала между этими крайними подходами, но ближе к левому краю. Она включает проектирование значительной части тестов по спецификациям, исходя из принципов: на каждую используемую функцию или возможность - хотя бы один тест, на каждую область и на каждую границу изменения какой-либо входной величины - хотя бы один тест, на каждый особый случай или на каждую исключительную ситуацию, указанные в спецификациях, - хотя бы один тест. Но она требует также проектирования некоторых тестов и по текстам программ, исходя из принципа (как минимум): каждая команда каждой программы ПО должна проработать хотя бы на одном тесте.

Оптимальную стратегию проектирования тестов можно конкретизировать на основании следующего принципа: для каждого программного документа (включая тексты программ), входящего в состав ПО, должны проектироваться свои тесты с целью выявления в нем ошибок. Во всяком случае, этот принцип необходимо соблюдать в соответствии с определением ПО и содержанием понятия технологии программирования как технологии разработки надежных ПО.

Мы будем придерживаться левой границы спектра, проектируя свои тесты на основании стандарта.

Тестирование — проблема в значительной сте­пени экономическая. Поскольку исчерпывающее тестирование не­возможно, мы должны ограничиться чем-то меньшим. Каждый тест должен давать максимальную отдачу по сравнению с нашими затра­тами. Эта отдача измеряется вероятностью тою, что тест выявит не обнаруженную прежде ошибку. Затраты измеряются временем и стоимостью подготовки, выполнения и проверки результатов теста. Считая, что затраты ограничены бюджетом и графиком, можно ут­верждать, что искусство тестирования, по существу, представляет собой искусство отбора тестов с максимальной отдачей. Более того, каждый тест должен быть представителем некоторого класса вход­ных значений, так чтобы его правильное выполнение создавало у нас некоторую убежденность в том, что для определенного класса входных данных программа будет выполняться правильно. Это обычно требует некоторого знания алгоритма и структуры програм­мы, и мы, таким образом, смещаемся к правому концу спектра.

Можно узнать при изучении ошибок в программе:

1. Лучше понять программу.

2. Осознать типичные ошибки.

3. Оценить удачность подхода к исправлению ошибки.

3.8 Метод массированного тестирования

К выбору тестового набора можно подходить с двух сторон: можно создавать специализированные наборы, удовлетворяющие сформулированному критерию полноты тестирования, а можно, наоборот, брать некоторые произвольные наборы и определять для них с использованием специальных инструментов, называемых анализаторами качества покрытия, степень их соответствия критерию.

4. Краткая характеристика области исследования

Текст в Международном Стандарте ИСО 9899 1999, определяющий требования считается нормативным. Весь остальной текст является информативным, т.е. исключительно с информационным смыслом. Кроме того, нормативный текст разделяется на две категории: требуемую и условную. Условно нормативный текст определяет требования для предопределенных свойств, т.е. тех, для которых синтаксис и семантика должны в точности соответствовать спецификации. Если какое-либо требования Международного Стандарта ИСО 9899 1999 нарушено, то поведение не определено. Неопределенное поведение определяется в стандарте словами «Неопределенное поведение» или отсутствием любого явно определенного поведения. Когда поведение компилятора неопределенно, тогда не имеет смысла это тестировать, т.к. нет эталона. Мы можем лишь это проверить и дать рекомендации, как избежать «ловушки».

Строго согласованная программа должна использовать только те свойства языка, которые описаны в Стандарте как требуемые. Это означает, что строго согласованная программа не может использовать условно нормативные свойства. Такая программа является независимой от любого не специфицированного, неопределенного или зависящего от реализации поведения.

Согласованная реализация C должна допускать любую строго согласованную программу.
Согласованная реализация C должна обеспечивать и поддерживать все типы, значения, объекты, свойства, методы, программный синтаксис и семантику, описанные в стандарте.

Согласованная реализация C не может успешно транслировать исходный код, содержащий препроцессорную директиву #error.

Согласованную реализацию C допускается снабжать дополнительными типами, значениями, объектами, методами и свойствами сверх тех, что описаны в стандарте, при условии, если только они не изменяют поведения строго согласованных программ.

Согласованная реализация C должна сопровождаться документом, в котором описаны все характеристики, зависящие от реализации, и все расширения.

 4.1. Иерархия проблем контроля конформности трансляторов.

Накопленный опыт в данной области позволяет выделить следующие уровни (срезы) проблем.

 Уровень 0. (или метауровень). Метастандарты языков программирования. Определение понятия конформности, стандарты на методы и средства контроля конформности.

 Уровень 1. Что контролировать? Стандарты языков программирования - формулировка требований к языковым процессорам (закрытый/открытый стандарт, виды и категории ошибок и т.д.). Требования к конформности языкового процессора (программ) должны быть сформулированы в стандарте языка программирования.

 Уровень 2. Как контролировать? Выбор подходящих методик построения полного комплекта, организация процедуры контроля конформности, способы автоматизации контроля, создание походящего инструментария.

 Уровень 3.  Частные методики контроля конформности трансляторов различным аспектам языкового стандарта: критерии полноты комплекта, способ его построения.

Все более значимой частью стандартов языка программирования становятся требования к диагностике. Детальное определение диагностического эффекта в декларативных операторов имеет свою специфику, требует дополнительных понятий, выразительных средств и ресурсов.

  4.2. Методика внешнего тестирования трансляторов.

 Задача  внешнего тестирования трансляторов (ВТТ) состоит в получении для проверяемого транслятора (входа) достоверного перечня его дефектов (выхода). Под дефектом будем понимать, за исключением специально оговоренных случаев, только несоблюдение стандарта.

Среди  критериев  качества ВТТ выделим критерий полноты комплекта тестов (позволяющий судить о полноте комплекта до прогона) и критерий значимости обнаруженных дефектов (связанный с оценкой возможных потерь пользователя из-за наличия дефектов различных категорий).

Методика выделяет следующие аспекты ВТТ: научный, языковый, организационный, инструментальный и прикладной.

В процессе ВТТ выделяются  фазы: проектирования, привязки, прогона и отчета.

Методика определяет категории (признаки классификации) тестов. Среди них:

 Т1-тесты тесты для тестирования "вширь", т.е. предназначенные для скрупулезного перебора условий на входные и выходные данные;

 Т2-тесты тесты для тестирования "вглубь", т.е. предназначенные для проверки тонких сочетаний условий и трудных для реализации и (или) понимания аспектов декларативных операторов;

 А-тесты  тесты, корректные по отношению к проверяемой документации (реализующиеся соответствующими стандарту программами);

 В-тесты тесты, некорректные по отношению к проверяемой документации; их цель - обнаружение дефектов в реакции на нарушение требований стандарта в обрабатываемых программах.

Основными способами повышения качества проектируемых тестов являются метод формальных моделей и метод частично-формализованных моделей.

Суть методов - в построении формальной (или частично-формализованной) модели для всего языка, отдельного раздела (группы разделов) описания языка или аспекта языка. Модель должна допускать несложное сопоставление с неформальным описанием языка. Назначение модели - обеспечить управление полнотой тестирования за счет явной формулировки критерия полноты и предоставления простых средств ее обеспечения.

Определим (неформально) комплект первого покрытия как комплект тестов, достаточно равномерно затрагивающий все аспекты и свойства декларативных операторов. Простейший способ частичной формализации критерия (полноты) первого покрытия - потребовать, чтобы для каждого утверждения определенного вида, содержащегося в тексте стандарта, в комплекте нашелся хотя бы один нацеленный на проверку этого утверждения тест.

Это весьма слабый критерий полноты (хотя бы потому, что проверяемые утверждения должны явно присутствовать в тексте стандарта, а не, скажем, выводиться из него; к тому же каждое содержательное утверждение может допускать различные интерпретации в зависимости от контекста и т.п.).

Оказывается достаточным для создания комплектов тестов, способных находить серьезные дефекты реализаций декларативных операторов. Суть метода в систематическом сканировании текста стандарта с целью создания и сопровождения следующих файлов:

1. ЧФ-модель текста стандарта. Из текста стандарта выделяются и фиксируются в этой модели подлежащие проверке утверждения. Структура модели соответствует структуре стандарта. Такая модель играет роль перечня подозрений; по сравнению с полным текстом стандарта она существенно короче и содержит лишь необходимую для данного вида тестирования информацию.

2. Комплект тестов (текущая версия). Каждое подозрение, зафиксированное в первом файле, детализируется в виде группы тестов. Уровень детализации определяется тестовиком, однако, учитывая, что перечень подозрений удовлетворяет относительно слабому критерию полноты и не может быть существенно улучшен в рамках данной методики, рекомендуется придерживаться принципа «один тест на подозрение».

Основное достоинство метода - возможность быстро создавать пригодные к практическому использованию фрагменты комплекта первого покрытия, привлекая относительно неопытный персонал; основной недостаток - непригодность для более сильного критерия полноты.

4.3 Метод проектирования тестов на основе специализированных частично-формализованных моделей языка программирования.

Этот метод дополняет предыдущий - позволяет повышать качество проектируемых тестов, однако требует дополнительных ресурсов и более высокой квалификации персонала. Отличительная особенность метода - в систематическом использовании специализированной ЧФМ, ориентированной на задачу контроля выбранного аспекта языка Си.

Примерами таких аспектов могут служить концепция типа, концепция параллелизма, правила видимости, предопределенные исключительные ситуации и т.п. В результате структура такой "узко специализированной" ЧФМ оказывается слабо связанной со структурой текстового представления стандарта, в отличие от ЧФМ из предыдущего пункта. С точки зрения качества контроля это обстоятельство положительное, так как оно способствует выработке у тестовика независимого взгляда на суть проверяемого аспекта, а тем самым - и созданию результативных тестов.

Определить диагностический эффект - это значит для каждой программы, содержащей нарушения и принадлежащей некоторому ареалу правильных программ, определить соответствующие ей диагнозы. К описывающей диагностический эффект модели предъявляются следующие содержательные требования:

- определяемые моделью диагнозы должны быть согласованы со стандартом языка (в частности, должны использовать терминологию стандарту ANSI ISO/IEC 9899:1999 и согласованную с зафиксированным в стандарте синтаксисом "систему координат");

- модель должна описывать "идеальную" диагностику (в частности, определяемый ею диагностический эффект должен удовлетворять критериям качества диагностики);

- модель должна быть основана на свойствах (особенностях) контекстных условий, инвариантных для "разумно" организованных языка программирования, и на свойствах (особенностях) контекстного анализа, инвариантных для "разумных" реализаций контекстного анализа.

Другими словами, ЧФМ ДЭ (диагностический эффект) должна описывать согласованную со стандартом диагностику нарушений контекстных условий, с большой вероятностью отражающую существенные свойства проверяемых реализаций.

Необходимость явного определения подлежащего проверке аспекта языка программирования помогает обнаруживать особо тонкие требования стандарта, выявлять аспекты и свойства реализаций, требующие особо тщательного контроля, и в конечном итоге - проектировать результативные Т2-тесты.

4.4. Специфика ЧФ-методологии.

ЧФ-методология ориентирована на работу с реальными объектами (стандарты языка программирования, комплекты тестов и т.п.). Укажем на следующие особенности исследуемой проблемной области.

Во-первых, существующие стандарты языка программирования представлены текстами на естественном языке. Уровень их формализации обычно ограничен формальным описанием лексики и синтаксиса и детальным структурированием текста.

Для объектов такого объема и такой сложности неизбежна частичная формализация, поскольку неизбежны противоречия, неоднозначности и неполнота в текстовом представлении стандарта языка программирования.

Так, трудности проектирования (диагностических) тестов непосредственно на основе текста стандарта просто вынуждают строить на его основе формализованные модели, помогающие управлять полнотой тестирования.

Во-вторых, при решении ряда задач (например, проектировании тестов) человеком (а не программой-генератором) полная формализация не является необходимой. Ему нужна не модель, определяющая языка программирования, а модель, позволяющая сформулировать подходящий

критерий полноты комплекта и проектировать в соответствии с ним тесты.

Наконец, практические задачи (контроль конформности, в частности) ставятся в рамках ресурсных ограничений по времени, финансам, квалификации персонала и т.п.

Таким образом, применение строгих математических методов в исследуемой области существенно ограничено.

  4.5. Диагностика. Общие положения.

Будем называть  диагнозом сообщение об отклонении от нормы (о нарушениях) в программе. Диагностикой назовем совокупность приемов, методов и алгоритмов оповещения о наличии и обстоятельствах нарушений, т.е. методику распознавания и выдачи диагнозов.

Тенденция к разработке и принятию закрытых стандартов (определяющих реакцию реализации на неправильные программы) сделала контроль диагностики частью контроля конформности со стандартом, а тесты с нарушениями стандарта (В-тесты, в отличие от правильных - А-тестов) - необходимым компонентом комплекта аттестационных тестов. Тем не менее, качество диагностики широко используемых трансляторов остается весьма невысоким, а вопросы контроля диагностики - наименее исследованными.

Особенности контроля диагностики современных стандартов языка программирования:

а) Диагностический (В-) эффект нечетко. Укажем основные причины этого.

Во-первых, требования к диагностике не управляют непосредственно поведением пользователя. Поэтому ему достаточно менее четких представлений о виде диагнозов, нежели о процессе работы правильных программ.

Во-вторых, В-эффект в значительной степени зависит от операционной среды.

Неопределенность В-эффекта оставляет излишнюю свободу реализаторам и приводит к многообразию в диагностике различных реализаций языка программирования и, как следствие, к низкому качеству диагностики. С другой стороны, для контроля В-эффекта его приходится

сначала проектировать (доопределять, уточнять определения стандарта), а лишь затем проверять.

б) Тестирование диагностики - это не только обнаружение случаев несоответствия реализации стандарту (как это происходит при А-тестировании), но и оценка качества диагностики.

Для этого необходимы система критериев и шкалы оценок. Исходя из сущности диагностики как первичной сигнализации о нарушениях в программе, можно заключить, что самые общие требования к ней - надежность и понятность. Понятной назовем диагностику, позволяющую пользователю, знакомому со стандартом языка программирования, без существенных интеллектуальных усилий распознать находящееся в программе нарушение.

Общие требования понятности и надежности нуждаются в детализации. Качество диагностики будет оцениваться по критериям:

-  фильтрации (диагностика приемлема лишь при условии, что всякой программе с нарушениями соответствует некоторый диагноз);

-  локализации (диагностика должна, возможно, точнее указать область нарушения);

-  классификации (диагностика должна, возможно, точнее охарактеризовать класс нарушений);

-  параметризации (диагностика тем лучше, чем лучше охарактеризованы параметры обнаруженного нарушения – компоненты неверного конструкта);

-  ясности (тексты диагнозов должны легко пониматься);

-  устойчивости (диагностика приемлема лишь при условии, что отсутствуют диагнозы для несуществующих нарушений и, в частности, нет каскадов сообщений, вызванных единственным нарушением).

Нетрудно заметить, что большая часть критериев диагностики может быть оценена только при визуальном просмотре протоколов трансляции. Шкала оценок критериев диагностики (кроме фильтрации) существенно шире, чем простое "прошел/не прошел", причем оценки могут оказаться весьма субъективными.

4.6. Классификация ошибок.

Определение языка делит ошибки на несколько различных категорий, которые должны быть обнаружены во время компиляции любым компилятором языка СИ.

Эти ошибки соответствуют любому пункту нарушения правил, данных в этом стандарте, кроме нарушений, соответствующих пунктам б) и в) (см. ниже). В частности, к этой категории относятся нарушения правил, в которых использованы слова  должно(must),  допустимо(allowed),  правильный(legal) или  неправильный (illegal). Любая, содержащая такую ошибку программа не является правильной; с другой стороны, тот факт, что программа правильна в этом смысле, не означает, что в ней нет других ошибок.

Обнаружение ошибки категории:

а) означает выдачу диагностического сообщения компилятором.

б) Ошибки, которые должны быть обнаружены во время выполнения программы.

Соответствующим ошибочным ситуациям сопоставлены имена предопределенных исключений. Каждый компилятор с языка должен генерировать код, возбуждающий соответствующее исключение, если такая ошибочная ситуация встретится во время выполнения программы. Если исключение обязательно будет возбуждаться при выполнении данной программы, то компиляторы могут (но не обязательно) сообщить об этом во время компиляции.

В самом деле эффект выполнения тестовой программы с ошибкой выполнения есть обработка исключения. Результат обработки такого теста оценивается по двухбалльной шкале (прошел/не прошел), а сам тест легко сделать самопроверяемым.

в)  Ошибочное выполнение.

В языке определен ряд правил, которым должна подчиняться программа, хотя от компилятора, и не требуется обнаружение нарушений этих правил ни во время компиляции, ни во время выполнения программы. Слово  ошибочный (erroneous) квалифицирует выполнение конструкций, содержащих ошибки этой категории. Результат выполнения ошибочной конструкции непредсказуем.

Поскольку стандарт не определяет реакцию на такого рода ошибки, то контроль такого рода ситуаций формально не требуется.

г)  Некорректная зависимость от порядка.

Когда в справочном руководстве (в данном случаи стандарте) указывается, что различные части данной конструкции должны быть выполнены  в порядке, который не определен в языке, это означает, что реализация допускает выполнение этих частей в любом порядке, но не параллельно. Более того, конструкция некорректна, если выполнение этих частей в различном порядке дает различный результат. Во время компиляции и во время выполнения программы (этот процесс называется выполнением (execution)) компилятор не всегда обеспечивает проверку некорректной зависимости результата о порядка..." В ряде случаев может возбуждаться исключение PROGRAM_ERROR.

Подведем некоторые итоги.

Таким образом, нас будут интересовать статические нарушения стандарта, о которых говорится в п. а). Из относящихся к нему ограничений наиболее уязвимой и трудной для проверки является реализация контекстно-зависимых свойств языка программирования. Подавляющая часть нарушений таких ограничений должна обнаруживаться языковым процессором при статическом контроле (в период компиляции).

Транслятор должен отвергать любые программы с нарушениями, явно зафиксированными в стандарте. Диагностика трансляторов включает только реакцию на нарушения периода компиляции: лексические, синтаксические нарушения и нарушения контекстно-зависимых свойств языка.

 4.7. Процедура тестирования диагностики.

Будем различать два этапа тестирования трансляторов: контроль конформности (формальную аттестацию) и оценку качества.

 Формальная аттестация  - процесс и результат проверки языкового процессора с целью установить, удовлетворяет ли он требованиям стандарта. В случае с диагностикой это получение ответа на вопрос: "Все ли программы с ошибками отвергаются (фильтруются) целевым транслятором?" В случае положительного ответа диагностика реализации считается конформной.

Успешное прохождение формальной аттестации не означает, что реализация пригодна к эксплуатации. Она может работать медленно, размер обрабатываемой программы может быть существенно ограничен, диагностические сообщения могут быть малоинформативные, а то и вовсе бесполезны и т.д. Но целью данной дипломной работы является контроль конформности.

5. Типы декларативных операторов языка C

Важное отличие языка СИ от других языков (PL1, FORTRAN, и др.) является отсутствие принципа умолчания, что приводит к необходимости объявления всех переменных используемых в программе явно вместе с указанием соответствующих им типов.

Объявления переменной имеет следующий формат:

[спецафикатор-класа-памяти] спецификатор-типа

описатель [=инициатор] [,описатель [= инициатор] ]

Описатель - идентификатор простой переменной либо более сложная конструкция с квадратными скобками, круглыми скобками или звездочкой (набором звездочек).

Спецификатор типа - одно или несколько ключевых слов, определяющие тип объявляемой переменной. В языке СИ имеется стандартный набор типов данных, используя который можно сконструировать новые (уникальные) типы данных.

Инициатор - задает начальное значение или список начальных значений, которые (которое) присваивается переменной при объявлении.

Спецификатор класса памяти - определяется одним из четырех ключевых слов языка СИ: auto, extern, register, static, и указывает, каким образом будет распределяться память под объявляемую переменную, с одной стороны, а с другой, область видимости этой переменной, т.е., из каких частей программы можно к ней обратиться.

Поскольку стандарт ANSI ISO/IEC 9899:1999 разработан намного позже выхода различных компиляторов языка программирования СИ, то в компиляторе может быть расширен функционал и набор операторов, но это не должно отражаться на ограничения которые накладывает стандарт.

5.1 Категории типов данных

Основные типы в CИ подразделяются на две группы: целочисленные типы и типы с плавающей точкой (для краткости их будем называть плавающими типами).

Ключевые слова для определения основных типов данных:

Целые типы: Плавающие типы:

char float

int double

short long double

long

signed

unsigned

Переменная любого типа может быть объявлена как немодифицируемая. Это достигается добавлением ключевого слова const к спецификатору-типа. Объекты с типом const представляют собой данные, используемые только для чтения, т.е. этой переменной не может быть присвоено новое значение. Отметим, что если после слова const отсутствует спецификатор-типа, то подразумевается спецификатор типа int.

Отметим, что ключевые слова signed и unsigned необязательны для большинства компиляторов, но нам это не подходит. Поэтому мы должны использовать эти ключевые слова. Они указывают, как интерпретируется нулевой бит объявляемой переменной, т.е., если указано ключевое слово unsigned, то нулевой бит интерпретируется как часть числа, в противном случае нулевой бит интерпретируется как знаковый. При этом самый левый бит области памяти, выделяемой для хранения значения, используется для представления знака или старшего бита значения. Если старший бит signed, установлен в 0, то значение переменной считается положительным. Если бит, установлен в 1, то значение переменной считается отрицательным. Если переменной типа char присваивается значение, выходящее за пределы допустимых значений, то происходит переполнение, и присвоенное значение является ошибочным. Однако в некоторых случаях компиляторы бывают написаны с учетом переполнения. Если планируется использовать такую программу с другим компилятором, который может представлять переменные типа char как unsigned, то для корректного выполнения программы в объявлении переменных типа char требуется использовать модификатор типа signed. В этом случае применение модификатора signed будет гарантировать представление переменных типа char с семью битами данных и одним битом в качестве знакового вне зависимости от особенностей конкретного Си-компилятора. По этому все тесты будут написаны с использованием ключевых слов signed и unsigned.

В CИ нет жёсткого стандарта на диапазоны значений арифметических типов (в стандарте языка оговариваются лишь минимально допустимые значения). В принципе, эти диапазоны определяются конкретной реализацией. Обычно выбор этих характеристик диктуется эффективностью использования вычислительных возможностей компьютера. Зависимость языка от реализации создаёт определённые проблемы переносимости. CИ остаётся машинно-зависимым языком. Здесь также многое зависит от реализации.

Плавающие типы используются для работы с вещественными числами, которые представляются в форме записи с десятичной точкой, так и в "научной нотации". Разница между нотациями становится очевидной из простого примера, который демонстрирует запись одного и того же вещественного числа в различных нотациях:

297.7

2.977*10**2

2.977E2

В научной нотации слева от символа E записывается мантисса, справа - значение экспоненты, которая всегда равняется показателю степени 10.

Для хранения значений плавающих типов в памяти используется специальный формат представления вещественных чисел. Этот формат называется IEEE форматом.

5.2 Диапазоны основных типов данных.

Рассмотрим диапазоны значений основных типов данных языка СИ.

5.2.1 Операторы декларирования целочисленных типов.

«Идентификатор» задает имя переменной или функции. Каждый идентификатор имеет тип, который устанавливается при его объявлении.

Имена типов данных и их сочетания с модификаторами типов используются для представления данных различных размеров в знаковом и беззнаковом представлении. Тестирование проводилось по закону «5.2.4.2.2 Characteristics of floating types ». Номер тест программы приводится в скобках.

Тип: Диапазон значений: Тестирование:

signed char min=-127, max=127 Тест (1.01, 1.02)

unsigned char min=0, max=255 Тест (1.03, 1.04)

signed short min=-32767, max=32767 Тест (1.05, 1.06)

unsigned short min=0, max=65535 Тест (1.07, 1.08)

signed short int min=-32767, max=32767 Тест (1.09, 1.10)

unsigned short int min=0, max=65535 Тест (1.11, 1.12)

signed int min=-32767, max=32767 Тест (1.13, 1.14)

unsigned int min=0, max=65535 Тест (1.15, 1.16)

signed long int min=-2147483647, max=2147483647 Тест (1.17, 1.18)

unsigned long int min=0, max=4294967295 Тест (1.19, 1.20)

signed long long int min=-9223372036854775807, max=9223372036854775807 Тест (1.21, 1.22)

unsigned long long int min=0, max=18446744073709551615 Тест (1.23, 1.24)

5.2.2 Возникновение переполнения

Анализ граничных условий - один из наиболее полезных методов проектирования тестов.

Обычно Си-компилятор представляет значение типа int, используя 16 битов. Следовательно, значения типа int находятся в диапазоне чисел от-32 768 до 32 767. Однако, если используется 32-разрядный компилятор, то он может представлять целые значения с помощью 32 битов. Это означает, что переменные типа int могут принимать значения в диапазоне целых чисел от -2 147 483 648 до 2 147 483 647. Когда делается попытка сохранить значение, выходящее за пределы допустимых значений для переменной типа int, возникает состояние переполнения, и присваиваемое значение является ошибочным.

Некоторые программы разрабатываются с пониманием того обстоятельства, что присвоенное ошибочное значение является следствием увеличения максимально или уменьшения минимально допустимого значения. Другими словами, программа написана с использованием переполнения. При переносе такой программы, использующей переменную типа int, из 16-разрядной в 32-разрядную среду, переполнения происходить не будут, поскольку 32-разрядное целое может хранить большее значение. С целью обеспечения свойства переносимости для программ, которые базируются на эффекте переполнения, следует использовать модификатор типа short. В этом случае компилятор гарантированно использует для представления значений переменных целого типа 16 битов.

Тип переменной определяет множество значений, которые может принимать переменная, и набор операций, которые могут быть выполнены на этих значениях. Например, переменные типа int могут принимать значения, лежащие в диапазоне от -32 768 до 32 767. При присваивании переменной типа int значения, выходящего за границы диапазона допустимых значений, вырабатывается ошибка переполнения. Самый старший бит используется для определения знака переменной. Если он равен 0, значение считается положительным. Если он равен 1, значение считается отрицательным. В этом случае для представления самих значений переменных используется 15 битов. Для того чтобы лучше понять, как происходит переполнение, рассмотрим поразрядное представление значений. Рассмотрим следующие значения:

0 0000 0000 0000 0000

1 0000 0000 0000 0001

2 0000 0000 0000 0010

3 0000 0000 0000 0011

4 0000 0000 0000 0100

…………….

32765 0111 1111 1111 1101

32766 0111 1111 1111 1110

32767 0111 1111 1111 1111

Если прибавить 1 к значению 32 767, то кажется, что можно ожидать результат, равный 32 768. Однако Си-компилятор вырабатывает значение, равное -32 768. Оно вычисляется следующим образом:

32767 0111 1111 1111 1111

+

1 0000 0000 0000 0001

_________________________

-32768 1000 0000 0000 0000

Программа демонстрирует переполнение, возникающее в программе Тест (2.01).

После компиляции и выполнения этой программы будет:

32767 + 1 равно -32768

-32768 - 1 равно 32767

Как можно видеть из приведенного примера, сложение значения 32 767 с 1 приводит к отрицательному числу, в то время как вычитание 1 из значения -32 768 приводит к положительному числу. Одной из проблем, вызывающих сложности при возникновении переполнения в программе, является то, что эта ошибка остается незамеченной. Другими словами, программа продолжает выполняться, даже если переполнение и имело место. Поэтому ошибку, возникающую в результате переполнения, достаточно сложно обнаружить.

Для того чтобы это проверить в тестируемом компиляторе проведем ряд тестов на проверку диапазона значений основных типов.

5.2.3 Операторы декларирования плавающих типов.

Специфическое представление чисел с плавающей запятой изменяется от машины к машине. Потому что, числа с плавающей запятой представляются внутренне как приблизительные количества, алгоритмы для управления данными с плавающей запятой часто должны принять во внимание точные характеристики конкретной машины. Заглавный файл " float .h " описывает формат.

Поскольку СИ остается машинозависимым языком программирования, то будем присваивать значения чуть больше оговоренных в стандарте диапазонов в каждой конкретной реализации компилятора СИ, и в тоже время будем сравнивать со значениями, указанными в стандарте. В результате сравнения значения конкретной реализации компилятора не должно быть меньше максимального значения стандарта и больше минимального значения стандарта.

Формально внутреннее представление числа с плавающей запятой может характеризоваться в терминах следующих параметров:

• Знак является или -1 или 1.

• Основа или основание системы счисления для возведения в степень, целое число больше чем 1. Это - константа для специфического представления.

• Экспонента, в которую основание возводится. Верхние и нижние пределы значения экспоненты - константы для специфического представления.

• Мантисса - целочисленное беззнаковое, которое является частью каждого числа с плавающей запятой.

• Точность мантиссы. Если основа представления - b, то точность - число из b цифр в мантиссе. Это - константа для специфического представления.

Разберем некоторые характеристики плавающих типов указанных в стандарте.

FLT_ROUNDS

Это значение характеризует режим округления для сложения с плавающей запятой:

-1 Режим - неопределенный

0 Округление к нулю.

1 Округление к самому близкому числу.

2 Округление к положительной бесконечности.

3 Округление к отрицательной бесконечности.

Любое другое значение представляет машинно-зависимый нестандартный режим округления. В большинстве реализаций значение FLT_ROUNDS установлено в 1, в соответствии со стандартом для чисел с плавающей запятой.

Таблица 1, показывающая, как некоторые значения округляются для каждого возможного значения FLT_ROUNDS.

Таблица 1

FLT_ROUNDS	0	1	2	3
1.00000003 1.00000007 -1.00000003 -1.00000007	1.0 1.0 -1.0 -1.0	1.0 1.00000012 -1.0 -1.00000012	1.00000012 1.00000012 -1.0 -1.0	1.0 1.0 -1.00000012 -1.00000012

FLT_RADIX

FLT_MANT_DIG – количество цифр в мантиссе.

FLT_DIG - число десятичных цифр точности для типа данных float. Если p и b - точность и основа (соответственно) для представления, то десятичная точность q - максимальное число десятичных цифр таких, что любое число с плавающей запятой с q-основанием из 10 цифр может быть округлено к числу с плавающей запятой с p-основанием из b цифр и обратно снова, без изменения q десятичных цифр. Значение этой макрокоманды, как предполагается, является, по крайней мере 6, для удовлетворения ANSI C.

FLT_MIN_EXP - самое маленькое возможное значение экспоненты для float типа. Более точно - минимальное отрицательное целое число такое, что значение FLT_RADIX в этой степени минус 1, может представляться как нормализованное число с плавающей запятой float типа.

FLT_MIN_10_EXP - минимальное отрицательное целое число такое, что 10 в этой степени минус 1, может представляться как нормализованное число с плавающей запятой float типа.

FLT_MAX_EXP - самое большое возможное значение экспоненты для float типа. Более точно, это - положительное максимальное целое число такое, что значение FLT_RADIX в этой степени минус 1.

FLT_MAX_10_EXP - максимальное положительное целое число такое, что 10 в этой степени минус 1, может представляться как нормализованное число с плавающей запятой float типа.

FLT_MAX - максимальное число типа float

FLT_MIN - минимальное число типа float

FLT_EPSILON - минимальное положительное число с плавающей запятой float типа такое, что 1.0 + FLT_EPSILON != 1.0 является истинным.

Все это справедливо не только для float, но и для double float, long double float.

Текст программы «проверка присваивание идентификатору типа Float различные выражения.

(Тест 2.02, 2.03). Проверка нормализации типа Float (Тест 2.04).

Этапы проверки плавающих типов:

1. Найдем максимальное количество разрядов мантиссе

2. Найдем максимально возможное положительное значение мантиссы

3. Найдем максимально возможное отрицательное значение мантиссы

4. Найдем максимальное количество разрядов в степени

5. Найдем максимально возможное положительное значение степени

6. Найдем максимально возможное отрицательное значение степени

7. Определим минимальное значение EPSILON

1. Найдем максимальное количество разрядов мантиссе

(Тест2.05) показывает максимальное количество разрядов мантиссе типа float float и одновременно проверим соответствие стандарту .

(Тест2.06) показывает максимальное количество разрядов мантиссе типа double float

Тест(2.07) показывает максимальное количество разрядов мантиссе типа long double float и одновременно проверим соответствие стандарту

2. Найдем максимально возможное положительное значение мантиссы

Блок схема тестирования максимального разряда мантиссы указана на рис. 21.

Началоfloat f=1.111111e38, int i=0Конец i = 0НЕТДА f f = f + 0.0000001e38f==9.999999e38НЕТДАдостигнуто 9.999999е38 i = 1Рис. 21. Схема тестирования максимального разряда мантисы

Тест(2.08) показывает максимально возможное положительное значение мантиссы float

Тест(2.09) показывает максимально возможное положительное значение мантиссы double float

Тест(2.10) показывает максимально возможное положительное значение мантиссы long double float

3. Найдем максимально возможное отрицательное значение мантиссы

Тест(2.11) показывает максимально возможное положительное значение мантиссы float

Тест(2.12) показывает максимально возможное положительное значение мантиссы double float

Тест(2.13) показывает максимально возможное положительное значение мантиссы long double float

4. Найдем максимальное количество разрядов в степени

Тест(2.14) показывает максимальное количество разрядов степени типа float

Тест(2.15) показывает максимальное количество разрядов степени типа double float

Тест(2.16) показывает максимальное количество разрядов степени типа long double float

5. Найдем максимально возможное положительное значение степени

Блок схема тестирования максимального разряда мантиссы указана на рис. 22.

Началоfloat f= 1e1, int i= 0Конец i = 0НЕТДА ff = f * 1 e 1f== 1e99НЕТДАдостигнуто 1е99 i = 1Рис. 22 Схема тестирования максимального разряда степени

Тест(2.17) показывает максимально возможное положительное значение степени float

Тест(2.18) проверим соответствие стандарту максимальной степени float

Тест(2.19) Найдем максимально возможное положительное значение степени double float

Тест (2.20) проверим соответствие стандарту степени double float

Тест(2.21) показывает максимально возможное положительное степени мантиссы long double float

Тест (2.22)/ проверим соответствие стандарту степени long double float

6. Найдем максимально возможное отрицательное значение степени

Тест(2.23) показывает максимально возможное отрицательное значение степени float

Тест (2.24) проверим соответствие стандарту степени float

Тест(2.25) показывает максимально возможное отрицательное значение степени double float

Тест (2.26) проверим соответствие стандарту степени double float

Тест(2.27) показывает максимально возможное отрицательное значение степени long double float

Тест (2.28) проверим соответствие стандарту степени long double float

7. Определим минимальное значение EPSILON (Точность представления чисел)

В компьютере числа представляются посредством комбинаций 0 и 1 (двоичных цифр). Поскольку представление значений определенного типа имеет фиксированное число битов, эти значения могут принадлежать только определенному диапазону. Если присваивается значение, находящееся вне диапазона допустимых значений для данного типа, происходит ошибка переполнения. В значениях с плавающей точкой, кроме того, что в них также имеет место переполнение, возможна потеря разрядов значимости, определяющих степень точности значения. Например, значения типа float допускают 7 значащих цифр. Предположим, например, что мы присваиваем переменной типа float значение 1.234567890. Поскольку тип float обеспечивает только 7 значащих цифр, точными будут только первые 7 цифр (1.234567). С другой стороны, значения типа double обеспечивают от 14 до 15 значащих цифр. В результате значение 1.234567890 может быть точно сохранено как значение типа double. При работе со значениями в формате с плавающей точкой следует помнить о том, что эти значения представляются с использованием фиксированного числа битов. Если так, то компьютер не в состоянии всегда представлять значения точно - в некоторых случаях представление значения с плавающей точкой содержит погрешность. Например, компьютер может представить значение 0.4 как 0.3999999 или значение 0.1 как 0.099999 и т.д.

Весьма часто простые дроби вроде 0.1 или 0.7 не могут конвертироваться в их внутренние двоичные представления без потери точности. Это может привести к парадоксальным результатам: например, floor((0.1+0.7)*10) обычно возвращает 7 вместо ожидаемого 8 как результат внутреннего представления приблизительного числа 7.9999999999....

Тест (2.29) между представлением с двойной и одинарной точностью

Величину машинного ипсилон можно вычислить как результат выполнения функции. Это показывает Тест (2.30) вычисления float EPSILON

Тест (2.31) правильный тест, вычисления double float EPSILON

Тест (2.32) правильный тест, вычисления long double float EPSILON

Тест (2.33) правильный тест, соответствие стандарту float EPSILON

Тест (2.34) правильный тест, соответствие стандарту double float EPSILON

Тест (2.35) правильный тест, соответствие стандарту long double float EPSILON

Если число не нормализовано, то можно вычитать 1 из экспоненты при умножении мантиссы на основу, и получать другое число с плавающей запятой с тем же самым значением. Нормализация состоит из выполнения этого неоднократно, пока число не нормализовано. Два различных нормализованных числа с плавающей запятой не могут быть равны в значении.

Помимо основных типов в CИ существуют специальные языковые средства, которые позволяют из элементов основных типов создавать новые, так называемые производные типы.

5.2.3 Побочные эффекты

«Побочные эффекты» или «ловушки» проявляются, когда при вычислении значения выражения меняется значение переменной. Все операции присвоения имеют побочные эффекты. Вызовы функций также могут иметь побочные эффекты, если они меняют значение внешного доступного элемента либо прямым присвоением, либо косвенным присвоением через указатель.

Порядок вычисления значения выражения зависит от конкретной реализации, за исключением гарантируемого языком программирования конкретного приритета выполнения операций.

Например, в следующем вызове функции возникает побочный эффект:

add(i+1,i=j+2)

Аргументы в вызове функции могут быть вычислены в произвольном порядке. Выражение i+1 может быть вычеслено как до выражения i=j+2, так и после него. Результат при этом будет разный.

Унарные операции увеличения и уменьшения значения используют присвоение, такие операции могут вызвать побочные эффекты, как это показано в следующем примере:

d = 0;

a = b++ = c++ = d++;

В этом примере значение a непредсказуемо. Значение d (первоначально 0) может быть присвоено с, затем b, а затем а до увеличения значения любой из переменных. В данном случае а будет равно 0.

Второй способ вычисления выражения начинается с вычисления операнда c++ = d++. Значение d (первонначально 0) присваивается с, а затем значения c и d увеличиваются. Далее, значение с (теперь 1) присваивается b, и значение b затем увеличивается. Наконец, увеличенное значение b присваивается а.

Язык СИ не задает порядок проведения вычислений при побочном эффекте, поэтому могут быть реализованы оба из описанных выше методов вычисления. Для обеспечения мобильности и ясности программ следует избегать операторов, которые зависят от конкретной последовательности проведения вычислений и могут вызвать побочные эффекты.

Побочными эффектами могут быть не правильный приоритет операций в сложных выражениях: (1+5)/4+7.

Большинство операторов СИ выполняют преобразование типа, чтобы привести операнды выражения к некоторому общему типу или для расширения коротких значений до размеров целого, который используется в машинных операциях. Выполняемые операторами СИ преобразования зависят от конкретных операторов и типов операнда или операндов и здесь так же возможны побочные эффекты.

Следующий пример демонстрирует применение приведенного алгоритма:

long l;

unsigned char uc;

int i;

f(l+uc*i);

Преобразование в данном примере будет проделано следующим образом:

1. uc преобразуется в тип unsigned int.

2. i преобразуется в тип unsigned int. Выполняется умножение и результатом будет тип unsigned int.

3. uc*i преобразуется в тип long.

Выполняется сложение и результатом будет тип long.

Можно заключать любой операнд в скобки без изменения типа или значения выражения. Например, в соледующем выражении скобки вокруг 10+5 означают, что величина 10+5 является левым операндом для оператора деления (/):

(10 + 5) / 5

Результатом (10+5)/5 будет 3. Без скобок, 10+5/5 даст своим результатом 11.

Хотя скобки и влияют на способ группирования операндов в выражении, они не могут гарантировать конкретный порядок проведения вычислений для всех случаев. Исключением будут "побочные эффекты"

5.3 Декларативные конструкции

Декларативная конструкция является языковой конструкцией, представляющей одно или более определений. Определение задает идентификатор или операцию для некоторой сущности, такой как схема, тип, значение, переменная, канал или аксиома.

Тип в инициализирующего выражения, входящего в объявление объекта, должен совпадать с типом объявляемого объекта. (Тест 3.01, 3.02, 3.03, 3.04)

Должна быть возможность объявлении нескольких переменных одного типа в одной строке язык С. (Тест 3.05, 3.06 )

Тип инициализирующего выражения, входящего в объявление объекта, должен совпадать с типом объявляемого объекта. (Тест 3.07, 3.08, 3.09)

Используются основные типы объявления идентификаторов без подключения библиотек (Тест 3.10)

Идентификатор объявлен одним основным типом, а присеваемое значение имеет другой тип.

(Тест 3.11)

В языке С использует знак равенства (=) в качестве оператора присваивания. Обычно операции присваивания значений переменным задаются на разных строках программы следующим образом:

count = 0;

sum =0;

value = 0;

При присваивании одного и того же значения нескольким переменным Си-компилятор позволяет выполнить эти операции одновременно следующим образом:

count = sum = value = 0;

Когда СИ компилятор встречает операцию множественного присваивания, он выполняет присваивание значения переменным справа налево. Несмотря на кажущееся удобство, рекомендуется, однако, использовать множественное присваивание только при инициализации переменных. Использование таких операций в более сложных операциях, вероятнее всего, снизит наглядность исходного кода программы. Например, в следующем фрагменте программы выполняется присваивание двум переменным кода буквы, введенной и преобразованной в прописную: Itr_save = letter = toupper(getchar());

(Тест 3.12 )

Переменные можно разделять по строкам произвольным образом. (Тест 3.13)

Операция sizeof

С помощью операции sizeof можно определить размер памяти, которая соответствует идентификатору или типу. Операция sizeof имеет следующий формат:

sizeof(выражение)

В качестве выражения может быть использован любой идентификатор, либо имя типа, заключенное в скобки. Отметим, что не может быть использовано имя типа void, а идентификатор не может относиться к полю битов или быть именем функции.

Размеры всех объектов в С кратны размеру char, и по определению значение sizeof(char) тождественно 1. (Тест 3.14)

Проверка логического выражения размерности типов:

1==sizeof(char)<=sizeof(short)<=sizeof(int)<=sizeof(long)

(Тест 3.15)

sizeof(float)<=sizeof(double)<=sizeof(long double)

(Тест 3.16)

sizeof(I)==sizeof(signed I)==sizeof(unsigned I), I может быть типа char, short, int или long.

(Тест 3.17, 3.18, 3.19, 3.20)

Значение константы не может быть изменено после инициализации.

(Тест 3.21)

Присваивание шестнадцатеричных или восьмеричных значений.

В зависимости от назначения прикладной программы могут возникнуть случаи, когда необходимо организовать работу с восьмеричными или шестнадцатеричными значениями. В таких случаях необходимо каким-нибудь образом сообщить компилятору, что те или иные значения не являются десятичными. Если числовому значению предшествует 0 (например 077), Си-компилятор трактует значение как восьмеричное. Если числовому значению предшествует Ох (например OxFF), компилятор рассматривает значение как шестнадцатеричное.

(Тест 3.22)

Операция деления на ноль.

(Тест 3.23)

Если объявляется переменная, но никогда не присваиваете ей значения, то компилятор выдает предупреждение, что на переменную нет ссылок.

(Тест 3.24)

Приведение значений разных типов при присваивании.

Тип определяет не только множество значений, которые переменная может принимать, и набор операций, которые могут быть выполнены на этих значениях. В некоторых случаях может потребоваться присвоить значение переменной типа int переменной типа float или наоборот. Вообще говоря, правила допускают такие операции, и они могут быть выполнены успешно. Однако следует соблюдать осторожность при присваивании, например, переменной типа int значения переменной типа float. При выполнении такой операции большинство компиляторов будет усекать числа с плавающей точкой, отбрасывая дробную часть. Однако некоторые компиляторы могут округлять присваиваемое значение. При присваивании переменной целого типа значения с плавающей точкой существует надежный способ получения предсказуемого результата, который заключается в использовании специальных функций или заранее приводит значения интификатора к требуемому типу.

5.4 Описание алгоритмов тестирование

В этом разделе описаны разработанные тест-программы согласно стандарту ИСО 9899 1999 по схеме рис. 23. Пунктуация законов, указанных в стандарте будет сохранена.

Изучение стандарта и написание кода программыНачалоТест-программаКонецРис. 23 Схема проверки на соответствия стандартаНЕТСоответствует стандартуЗапуск тест-программыКомпилятор выдает ошибкуВыводится сообщение «Ok»ДАВыводится сообщение «False»Анализ полученной ошибки, исправления

5.4.1 Арифметическая операция сложения с плавающем типов.

Проверим арифметическую операцию сложение с плавающими типами, чтобы результат переводился к типу большему чем полученный результат.

Закон:

5.2.4.2.2 Характеристики плавающих типов

П.7 Значения операций с плавающими операндами и значениями, подчиненными к обычной арифметике преобразования и плавающих констант оценены к формату чей диапазон и точность может быть больший, чем требуемый типом. Использование форматов оценки характеризовано определенным выполнением значением FLT_EVAL_METHOD: 19)

Англ: «The values of operations with floating operands and values subject to the usual arithmetic

conversions and of floating constants are evaluated to a format whose range and precision may be greater than required by the type. The use of evaluation formats is characterized by the implementation-defined value of FLT_EVAL_METHOD:19)»

(Тест 4.01 - 4.12)

5.4.2 Объявление индентификаторов

Закон:

6.2.1

п.1 «Тот же самый идентификатор может обозначить различные объекты в различных точках в программы».

Англ.: « The same identifier can denote different entities at different points in the program.»

Если в середине программы объявить переменную, то переменная должна иметь уже новое значение с типом объявленном в начале.

Началоsigned int i = 32767 ichar i=«tip char» ii == «tip char»КонецРис. 24 Схема тестирования объявления переменныхНЕТДАВыводится сообщение «False»Выводится сообщение «Ok»

Блок схема тест программы 5.01 изображена на рис. 24.

(Тест 5.01 - 5.09)

Закон: объявление меток.

П.3

Имя метки - единственный вид идентификатора, который имеет функциональные возможности. Это может использоваться (в Goto инструкциях) где-нибудь в функции, в которой это появляется, и объявлено неявно его синтаксическим появлением (сопровождение и инструкция).

Англ.: « A label name is the only kind of identifier that has function scope. It can be used (in a

goto statement) anywhere in the function in which it appears, and is declared implicitly by its syntactic appearance (followed by a : and a statement).»

Оператор goto – это передача управления, с помощью которого можно продолжить выполнение программы с определенного места, называемого меткой. Оператор goto имеет следующий формат:

goto метка;

метка:

Тест(5.10)

Закон:

Метка оператора goto должна находиться в текущей функции. Другими словами, невозможно использовать goto для перехода по метке, которая объявлена в другой функции, или наоборот.

Тест ( 5.11)

Определение структуры.

Структуры - это составной объект, в который входят элементы любых типов, за исключением функций. В отличие от массива, который является однородным объектом, структура может быть неоднородной. Тип структуры определяется записью вида:

struct { список определений }

В структуре обязательно должен быть указан хотя бы один компонент. Определение структур имеет следующий вид:

тип-данных описатель;

где тип-данных указывает тип структуры для объектов, определяемых в описателях. В простейшей форме описатели представляют собой идентификаторы или массивы.

Пример:

struct { double x,y; } s1, s2, sm[9]; struct { int year; char moth, day; } date1, date2;

Переменные s1, s2 определяются как структуры, каждая из которых состоит из двух компонент х и у. Переменная sm определяется как массив из девяти структур. Каждая из двух переменных date1, date2 состоит из трех компонентов year, moth, day. Существует и другой способ ассоциирования имени с типом структуры, он основан на использовании тега структуры. Тег структуры аналогичен тегу перечислимого типа. Тег структуры определяется следующим образом:

struct тег { список описаний; };

где тег является идентификатором.

В приведенном ниже примере идентификатор student описывается как тег структуры:

struct student { char name[25]; int id, age; char prp; };

Тег структуры используется для последующего объявления структур данного вида в форме:

struct тег список-идентификаторов;

Пример:

struct studeut st1,st2;

Доступ к компонентам структуры осуществляется с помощью указания имени структуры и следующего через точку имени выделенного компонента, например:

st1.name="Иванов"; st2.id=st1.id; st1_node.data=st1.age;

Закон:

П.7

Структуры, союз, и перечисления имеют возможности, которые начинаются только после появления отметка в спецификаторе типа, который объявляет отметку. Каждая константа перечисления имеет возможности, который начинается только после появления его определения enumerator в списке enumerator. Любой другой идентификатор имеет возможности, которые начинаются только после завершения ее declarator.

Англ.: « Structure, union, and enumeration tags have scope that begins just after the appearance of

the tag in a type specifier that declares the tag. Each enumeration constant has scope that begins just after the appearance of its defining enumerator in an enumerator list. Any other identifier has scope that begins just after the completion of its declarator.»

Т.е. до структура должна быть в начале декларирована до того как она будет использована.

(Тест 5.12, 5.13)

Закон:

6.2.2

П.2 «В пределах одного модуля трансляции, каждая декларация идентификатора с внутренней свзью обозначает тот же самый объект или функцию. Каждая декларация идентификатора без связи обозначает уникальный объект.»

Англ.: «In the set of translation units and libraries that constitutes an entire program, each

declaration of a particular identifier with external linkage denotes the same object or function. Within one translation unit, each declaration of an identifier with internal linkage denotes the same object or function. Each declaration of an identifier with no linkage denotes a unique entity.»

(Тест 5.14, 5.15 )

Закон:

п.4

Для идентификатора, объявленного со спецификатором класса памяти extern в контексте, в который предшествующее объявление того идентификатора видимо, 23) если предшествующая декларация определяет внутренний или внешнее редактирование. Редактирование идентификатора при более поздней декларации - тот же самый как редактирование, указанное при предшествующей декларации. Если никакая предшествующая декларация не видима, или если предшествующая декларация не определяет никакое редактирование, тогда идентификатор имеет внешнее редактирование. 23) Как определено в 6.2.1, более позднее объявление могло бы скрыть предшествующее объявление.

Англ.: «For an identifier declared with the storage-class specifier extern in a scope in which a

prior declaration of that identifier is visible,23) if the prior declaration specifies internal or external linkage, the linkage of the identifier at the later declaration is the same as the linkage specified at the prior declaration. If no prior declaration is visible, or if the prior declaration specifies no linkage, then the identifier has external linkage.»

Т.е. если переменная не определена, то она, возможно, определяется внешнее линкование.

(Тест 5.15, 5.16)

5.4.3 Имена идентификаторов

Закон:

6.2.3 Имена идентификаторов

п.23 «более поздняя декларация должна скрывать предшествующую декларацию.»

Англ.: «the later declaration might hide the prior declaration.»

Началоsigned int i = 32767 ii == 65535КонецРис. 25 Поздняя декларация должна скрывать предшествующую декларациюНЕТДАВыводится сообщение «False»Выводится сообщение «Ok»unsigned int i = 65535 iВыводится сообщение «Ok»

Блок схема тест программы 5.18 изображена на рис. 25.

Тест (5.18,5.19)

Закон:

Тип в выражения идентификатора, входящего в объявление объекта, должен совпадать с типом объявляемого объекта. Тест (5.20,5.21)

5.4.4 Продолжительности хранения объектов

Закон:

6.2.4 Продолжительности хранения объектов

П.2

Время хранения объекта – это часть выполнения программы, в течение которого будет гарантированно сохранность объекта в памяти. Объект имеет базовый адрес, 25) и сохраняет его последнее-сохраненное значение повсюду его срока хранения 26) Если объект относится к внешней стороне его срок хранения, поведение неопределенно.

Значение указателя становится неопределенным когда объект, на который это указывает, достигает конца его срока службы(продолжительности жизни).

Т.е. Объявленный в начале программы идентификатор должен хранится все время работы программы(жизненного цикла), если он не будет переопределен. И проверить значение указателя.

25) Термин "базовый адрес"(constant address) означает, что два указателя на объект, возможно, созданный в различный времена сравнятся равный. Адрес может быть различен в течение двух различных выполнения тот же самый программа.

Англ.: «The lifetime of an object is the portion of program execution during which storage is

guaranteed to be reserved for it. An object exists, has a constant address,25) and retains its last-stored value throughout its lifetime.26) If an object is referred to outside of its lifetime, the behavior is undefined. The value of a pointer becomes indeterminate when the object it points to reaches the end of its lifetime.»

(Тест 5.22, 5.23)

Закон:

П.5

Для такого объекта, который не имеет тип массива переменной длины, его срок хранения простирается от входа в блок, с которым это связано до выполнения того конца блока в другой объект. (Ввод приложенного блока или запроса функции приостанавливает, но не заканчивается выполнение текущего блока.) Если блок введен рекурсивно, новый случай объект создан каждый раз. Начальное значение объекта неопределенно. Если инициализация определена для объекта, это выполнено, каждый раз декларация достигнутый в выполнении блока; иначе, значение становится неопределенным каждый время декларация достигнуто.

Англ.: «For such an object that does not have a variable length array type, its lifetime extends from entry into the block with which it is associated until execution of that block ends in any way. (Entering an enclosed block or calling a function suspends, but does not end, execution of the current block.) If the block is entered recursively, a new instance of the object is created each time. The initial value of the object is indeterminate. If an initialization is specified for the object, it is performed each time the declaration is reached in the execution of the block; otherwise, the value becomes indeterminate each

time the declaration is reached.»

(Тест 5.24)

Закон:

П.6

Для такого объекта, который имеет, тип массива переменной длины, его срок службы(продолжительность жизни) простирается от декларация объекта до выполнения программы оставляет возможности декларация 27) Если возможности(контекст) введены рекурсивно, новый случай объекта, создается каждый раз. Начальное значение объекта неопределенно.

27) Оставление самого внутреннего блока, содержащего декларацию, или скачущий к точке в том блоке или внедренный блок до декларации, оставляет возможности(контекст) декларации.

Англ.: «For such an object that does have a variable length array type, its lifetime extends from the declaration of the object until execution of the program leaves the scope of the declaration.27) If the scope is entered recursively, a new instance of the object is created each time. The initial value of the object is indeterminate.»

(Тест 5.25)

5.4.5 Типы значений индентификаторов

Закон:

6.2.5 Типы

П.3

Если элемент основного набора символов выполнения сохранен в объект char, его значение гарантировано, будет положительным.

Англ.: «An object declared as type char is large enough to store any member of the basic execution character set. If a member of the basic execution character set is stored in a char object, its value is guaranteed to be positive. If any other character is stored in a char object, the resulting value is implementation-defined but shall be within the range of values that can be represented in that type.»

Если присвоить символ переменной объявленной как char, то его значение будет положительно.

Тест ( 6.01)

Закон:

П.4

Имеются пять стандартных типов signed integer, designated или signed char, short

int, int, long int, и long long int. (Эти и другие типы могут быть обозначенный несколькими дополнительными способами, как описано в 6.7.2.) может также иметься определенное выполнением предопределенного типа extended signed integer 28) стандарт и расширенный тип signed integer все вместе называются тип signed integer 29)

—short int or signed short int

— unsigned short or unsigned short int

— signed or signed int

— unsigned or unsigned int

— long int or signed long int

— unsigned long or unsigned long int

—long long int or signed long long int

— unsigned long long or unsigned long long int

Англ.: «There are five standard signed integer types, designated as signed char, short int, int, long int, and long long int. (These and other types may be designated in several additional ways, as described in 6.7.2.) There may also be implementation-defined extended signed integer types.28) The standard and extended signed integer types are collectively called signed integer types.29)»

Проверить зарегистрированные имена типов, их объявление должно быть индентичным. Заменяем типы переменных «or».

(Тест 6.02 - 6.011)

Закон:

П.5

Объект, объявленный как тип signed char, занимает то же самое количество памяти как и «обычный» тип char.

Англ.: «An object declared as type signed char occupies the same amount of storage as a «plain» char object.»

Проверить этот закон через оператор sizeOf.

(Тест 6.12)

Закон:

П.6

То же самое что и в п.5 только для signed int и unsigned int.

(Тест 6.13)

Закон:

П.9

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

Т.е. переполнение не происходит, но записывается максимальное число которое может быть представлено этим типом.

Англ.: «The range of nonnegative values of a signed integer type is a subrange of the corresponding unsigned integer type, and the representation of the same value in each type is the same.31) A computation involving unsigned operands can never overflow, because a result that cannot be represented by the resulting unsigned integer type is reduced modulo the number that is one greater than the largest value that can be represented by the resulting type.»

(Тест 6.14)

Закон:

П.10

Для любых двух целочисленных типов с тем же самым signedness и различным целочисленным конверсионным рангом (см. 6.3.1.1), диапазон значений типа с меньшим целочисленным конверсионным рангом - поддиапазон значений другого типа.

Т.е. присваивать значении одного диапазона другому, чтобы проверить что меньший под диапазон является большего поддиапазона.

Англ.: «There are three real floating types, designated as float, double, and long double.32) The set of values of the type float is a subset of the set of values of the type double; the set of values of the type double is a subset of the set of values of the type long double.»

(Тест 6.15 - 6.16)

Закон:

П.35)

CHAR_MIN, определенный в , будет иметь одно из значений 0 или SCHAR_MIN, и это может быть используемым, чтобы отличить эти два параметра.

Англ.: «CHAR_MIN, defined in , will have one of the values 0 or SCHAR_MIN, and this can be used to distinguish the two options. Irrespective of the choice made, char is a separate type from the other two and is not compatible with either.»

Проверим отличия знакового и без знакового типа CHAR.

(Тест 6.17)

Закон:

П.36)

Так как типы объекта не включают неполные типы, множество неполного типа не может быть построено.

Англ.: «Since object types do not include incomplete types, an array of incomplete type cannot be constructed.»

В этом тесте объявим массив с большим числом элементов, а использовать меньшее, он не должен быть создан в таком случаи или выдать предупреждение.

(Тест 6.18 – 6.19)

Закон:

П.27

ПРИМЕРА 1 тип, обозначенный как " float * " имеет тип " указатель на с плавающей точкой ". Его категория типа указатель, не floating тип.

Англ.: « EXAMPLE 1 The type designated as ‘‘float *’’ has type ‘‘pointer to float’’. Its type category is pointer, not a floating type. The const-qualified version of this type is designated as ‘‘float * const’’ whereas the type designated as ‘‘const float *’’ is not a qualified type — its type is ‘‘pointer to constqualified float’’ and is a pointer to a qualified type.

Т.е. проверить что указатель не был типом Float.

(Тест 6.20)

5.4.6 Представления типов

Закон:

6.2.6 Представления типов

6.2.6.1 Генерал

П.6

Когда значение сохранено в объекте типа структуры или объединения, включая в объект члена, байты объектного представления, которые соответствуют любым дополнительным байтам, берут неопределенные значения 42), значения дополнительных байтов не должны затрагивать, является ли значение такого объекта представлением западни. Те биты объекта структуры или объединения, которые находятся в том же самом байте как член битового поля, но - не часть того члена, не должны подобно затрагивать, является ли значение такого объекта представлением западни.

Значение одного типа присваивается другому типу, входящему в поддиапазон. Старшие биты не должны быть строго определенны.

Тесты уже определены в 6.2.5 Типы П.4

Закон:

П.7

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

Англ.: «When a value is stored in a member of an object of union type, the bytes of the object representation that do not correspond to that member but do correspond to other members take unspecified values, but the value of the union object shall not thereby become a trap representation.»

Т.е. массив объявляется одного типа, а один из членов другого типа. И те байты, которые не соответствую всем остальным члена берут неопределенное значение.

(Тест 7.01, 7.02)

6.2.6.2 Целочисленные типы

П.1

Для unsigned integer напечатает другой чем unsigned char, биты объекта представление должно быть разделено на две группы: биты значения и дополнительные биты (там нуждаются не, быть любой из последнего). Если имеются биты значения N, каждый бит должен представить различную мощность 2 между 1 и 2N-1, так, чтобы объекты того типа были способны к представление значений от 0 до 2N - 1 использование чистое двоичное представление; это должно быть известный как представление значения. Значения любых дополнительных битов неопределенны 44)

Англ.: «For unsigned integer types other than unsigned char, the bits of the object representation shall be divided into two groups: value bits and padding bits (there need not be any of the latter). If there are N value bits, each bit shall represent a different power of 2 between 1 and 2N-1, so that objects of that type shall be capable of representing values from 0 to 2N - 1 using a pure binary representation; this shall be known as the value representation. The values of any padding bits are unspecified.44)»

44) Некоторые комбинации дополнительных битов могли бы генерировать представления ловушки, например, если одно дополнительный бит - бит четности. Независимо, никакая арифметическая операция на правильных(допустимых) значениях не может генерировать ловушку другое представление чем, как часть исключительного условия(состояния) типа переполнения, и этого не может происходить с типами без знака. Все другие комбинации дополнительных битов - альтернативные объектные представления значение, указанное битами значения.

Т.е. проверить для типов unsigned int и unsigned char формулу от 0 до 2N – 1.(255=2*128-1)

Проверить все арифметические операции и после чего определить тип полученного объекта, чтоб не был изменен знак.

Началоsigned int w= -120, t= -1 i = w * tКонецРис. 26 Схема тестирования арифметических операций i > 0Выводится сообщение «Ok»Выводится сообщение «False»НЕТДАsigned int w= -120, t= 1 i = w * t i < 0Выводится сообщение «Ok»Выводится сообщение «False»НЕТДА i = w + t i < 0Выводится сообщение «Ok»Выводится сообщение «False»НЕТДА

Блок схема части тест-программы 7.12 изображена на рис. 26 проверяет корректную работу с доролнительными знаковыми битами.

(Тест 7.03 -7.26)

Закон:

П. 2 и 3

Для типа signed integer в случае признака, и величина, и дополнение, если это представление - нормальное значение, это называются отрицательный ноль.

Должен иметься только один знаковый разряд.

- and, |, ^, ~, < <, > > операторы с параметрами, которые производят такое значение;

- +, -, *, /, % операторы, где один параметр - отрицательный ноль и результат ноль;

- Составные операторы основанные назначения на вышеупомянутых случаях неопределенно, генерируют ли эти случаи фактически отрицательный ноль или нормальный ноль или отрицательный ноль становится нормальным нолем когда сохранено в объекте.

Англ.: «Which of these applies is implementation-defined, as is whether the value with sign bit 1 and all value bits zero (for the first two), or with sign bit and all value bits 1 (for one’s complement), is a trap representation or a normal value. In the case of sign and magnitude and one’s complement, if this representation is a normal value it is called a negative zero.

If the implementation supports negative zeros, they shall be generated only by:

— the &, |, ^, ~, <<, and >> operators with arguments that produce such a value;

— the +, -, *, /, and % operators where one argument is a negative zero and the result is zero;

— compound assignment operators based on the above cases.

It is unspecified whether these cases actually generate a negative zero or a normal zero, and whether a negative zero becomes a normal zero when stored in an object.»

Если значение 11111111 типа без знаковый присвоить значению со знаком 1.111111 и наоборот. Если знаковый разряд один то при без знаковом типе на один разряд должно увеличится диапазон.

(Тест 7.27 - 7.32)

При арифметических операциях получить отрицательный ноль 1.00000.

(Тест 7.33 – 7.43)

Т.е. получить отрицательный ноль и использовать его в арифметических операциях и результат должен быть равен 0.

(Тест 7.44, 7.45)

Т.е. в составных операторах(когда используется не одно арифметическое действие) результат не определен, т.е. нужно проверить что будет в результате эти случаи фактически отрицательный ноль или нормальный ноль или отрицательный ноль становится нормальным нолем когда сохранено в объекте.

(Тест 7.46, 7.47)

Закон:

П.5

Значения любых дополнительных битов неопределенны 45) правильны(допустимы) (не должна быть сгенерирована «ловушка») объектное представление из типа signed integer, где знаковый разряд нулевой - правильное(допустимое) объектное представление передача типа unsigned и должна представить то же самое значение.

Англ.: « The values of any padding bits are unspecified.45) A valid (non-trap) object representation of a signed integer type where the sign bit is zero is a valid object representation of the corresponding unsigned type, and shall represent the same value.»

45) Некоторые комбинации дополнительных битов могли бы генерировать представления ловушки, например, если одно дополнение бит - бит четности. Независимо, никакая арифметическая операция на правильных(допустимых) значениях не может генерировать ловушку. Представление другое чем как часть исключительного условия(состояния) типа переполнения. Все другие комбинации дополнительных битов - альтернативные объектные представления значения, указанного значением биты.

Англ: «Some combinations of padding bits might generate trap representations, for example, if one padding bit is a parity bit. Regardless, no arithmetic operation on valid values can generate a trap representation other than as part of an exceptional condition such as an overflow. All other combinations of padding bits are alternative object representations of the value specified by the value bits.»

Положительное значение signed integer это тоже самое, что и unsigned integer. При арифметических операциях не должны искажаться данные(не зависимо от доп. битов).

(Тест 7.48 – 7.50)

5.4.7 Преобразования

При выполнении операций происходят неявные преобразования типов в следующих случаях:

- при выполнении операций осуществляются обычные арифметические преобразования;

- при выполнении операций присваивания, если значение одного типа присваивается переменной другого типа;

- при передаче аргументов функции.

Кроме того, в Си есть возможность явного приведения значения одного типа к другому.

В операциях присваивания тип значения, которое присваивается, преобразуется к типу переменной, получающей это значение. Допускается преобразования целых и плавающих типов, даже если такое преобразование ведет к потере информации.

Преобразование целых типов со знаком. Целое со знаком преобразуется к более короткому целому со знаком, посредством усечения старших битов. Целая со знаком преобразуется к более длинному целому со знаком, путем размножения знака. При преобразовании целого со знаком к целому без знака, целое со знаком преобразуется к размеру целого без знака и результат рассматривается как значение без знака.

Преобразование целого со знаком к плавающему типу происходит без потери информации, за исключением случая преобразования значения типа long int или unsigned long int к типу float, когда точность часто может быть потеряна.

Преобразование целых типов без знака. Целое без знака преобразуется к более короткому целому без знака или со знаком путем усечения старших битов. Целое без знака преобразуется к более длинному целому без знака или со знаком путем дополнения нулей слева.

Когда целое без знака преобразуется к целому со знаком того же размера, битовое представление не изменяется. Поэтому значение, которое оно представляет, изменяется, если знаковый бит установлен (равен 1), т.е. когда исходное целое без знака больше чем максимальное положительное целое со знаком, такой же длины.

Целые значения без знака преобразуются к плавающему типу, путем преобразования целого без знака к значению типа signed long, а затем значение signed long преобразуется в плавающий тип. Преобразования из unsigned long к типу float, double или long double производятся с потерей информации, если преобразуемое значение больше, чем максимальное положительное значение, которое может быть представлено для типа long.

Преобразования плавающих типов. Величины типа float преобразуются к типу double без изменения значения. Величины double и long double преобразуются к float c некоторой потерей точности. Если значение слишком велико для float, то происходит потеря значимости, о чем сообщается во время выполнения.

При преобразовании величины с плавающей точкой к целым типам она сначала преобразуется к типу long (дробная часть плавающей величины при этом отбрасывается), а затем величина типа long преобразуется к требуемому целому типу. Если значение слишком велико для long, то результат преобразования не определен.

Преобразования из float, double или long double к типу unsigned long производится с потерей точности, если преобразуемое значение больше, чем максимально возможное положительное значение, представленное типом long.

Преобразование типов указателя. Указатель на величину одного типа может быть преобразован к указателю на величину другого типа. Однако результат может быть не определен из-за отличий в требованиях к выравниванию и размерах для различных типов.

Указатель на тип void может быть преобразован к указателю на любой тип, и указатель на любой тип может быть преобразован к указателю на тип void без ограничений. Значение указателя может быть преобразовано к целой величине. Метод преобразования зависит от размера указателя и размера целого типа следующим образом:

- если размер указателя меньше размера целого типа или равен ему, то указатель преобразуется точно так же, как целое без знака;

- если указатель больше, чем размер целого типа, то указатель сначала преобразуется к указателю с тем же размером, что и целый тип, и затем преобразуется к целому типу.

Целый тип может быть преобразован к адресному типу по следующим правилам:

- если целый тип того же размера, что и указатель, то целая величина просто рассматривается как указатель (целое без знака);

- если размер целого типа отличен от размера указателя, то целый тип сначала преобразуется к размеру указателя (используются способы преобразования, описанные выше), а затем полученное значение трактуется как указатель.

Преобразования при вызове функции. Преобразования, выполняемые над аргументами при вызове функции, зависят от того, был ли задан прототип функции (объявление "вперед") со списком объявлений типов аргументов.

Если задан прототип функции и он включает объявление типов аргументов, то над аргументами в вызове функции выполняются только обычные арифметические преобразования.

Эти преобразования выполняются независимо для каждого аргумента. Величины типа float преобразуются к double, величины типа char и short преобразуются к int, величины типов unsigned char и unsigned short преобразуются к unsigned int. Могут быть также выполнены неявные преобразования переменных типа указатель. Задавая прототипы функций, можно переопределить эти неявные преобразования и позволить компилятору выполнить контроль типов.

Преобразования при приведении типов. Явное преобразование типов может быть осуществлено посредством операции приведения типов, которая имеет формат:

( имя-типа ) операнд .

В приведенной записи имя-типа задает тип, к которому должен быть преобразован операнд.

Пример:

int i=2;

long l=2;

double d;

float f;

d=(double)i * (double)l;

f=(float)d;

В данном примере величины i,l,d будут явно преобразовываться к указанным в круглых скобках типам. Вернемся к тестированию стандарта.

Закон:

6.3 Преобразования

П.2

Преобразование значения операнда к совместимому типу не причиняет никакое изменение к значению или представление.

Англ: «Conversion of an operand value to a compatible type causes no change to the value or the representation.»

При преобразовании не должно меняться значение.

Тест ( 8.01 – 8.06)

Закон:

6.3.1.2 Булев тип

П.1

Когда любое скалярное значение преобразовано(конвертировано) к _Bool, результат - 0, если значение сравнивается равный 0; иначе, результат - 1.

Англ.: « When any scalar value is converted to _Bool, the result is 0 if the value compares equal to 0; otherwise, the result is 1.

Любое значение конвертировано к Bool – результат 0, если значение сравнивается с 0, то результат 1.

Тест (8.07)

Закон:

6.3.1.3 Signed и unsigned integers

П.1

Когда значение с целочисленным типом преобразовано(конвертировано) к другому целому числу, представление другой чем _Bool, если значение может быть представлено новым типом, это неизменяемо.

Англ: «When a value with integer type is converted to another integer type other than _Bool, if the value can be represented by the new type, it is unchanged.»

Тест (8.08, 8.09)

П.2

Иначе, если новый тип без знака, значение преобразовано(конвертировано), неоднократно добавляя или вычитающий еще один чем максимальное значение, которое может быть представлено в новом типе пока значение не находится в диапазоне нового типа

Англ: «Otherwise, if the new type is unsigned, the value is converted by repeatedly adding or subtracting one more than the maximum value that can be represented in the new type until the value is in the range of the new type.49)»

(Тест 8.10 – 8.12)

Закон:

6.3.1.4 Реальный плавающий и целочисленный

П.1

Когда конечное значение float типа преобразовано(конвертировано) к целому числу, напечатает другой чем _Bool, дробная часть отвергнута (то есть, значение усечено к нолю). Если значение неотъемлемая часть не может быть представлена целочисленным типом, поведение неопределенно 50)

Англ: «When a finite value of real floating type is converted to an integer type other than _Bool, the fractional part is discarded (i.e., the value is truncated toward zero). If the value of the integral part cannot be represented by the integer type, the behavior is undefined.50)»

Т.е. преобразование типа float к signed int и signed long long int.

(Тест 8.13)

Закон:

50) Remaindering выполненная операция, когда значение целочисленного типа преобразовано(конвертировано) к типу без знака потребность не выполнена, когда значение реального плавающего типа преобразовано(конвертировано) к типу без знака. Таким образом, диапазон портативных реальных плавающих значений (-1, Utype_MAX+1).

Точность результата является или самым близким выше или самое близкое более низкое перепрезентабельное значение, выбранное в определенной выполнением манере. Если преобразовываемое(конвертированное) значение - вне диапазона значения, которые могут быть представлены, поведение, неопределенны.

Англ: «The remaindering operation performed when a value of integer type is converted to unsigned type need not be performed when a value of real floating type is converted to unsigned type. Thus, the range of portable real floating values is (-1, Utype_MAX+1).»

Т.е. при преобразовании типа float к int дробная часть отбрасывается. Если дробная часть не может быть представлена в int, тогда поведение не определено. Таким образом, значение, которое может быть конвертировано лежит в диапазоне float (-1, Max+1). Если значение находится в не диапазона, то поведение не определенно.

(Тест 8.14 – 8.21)

Закон:

6.3.1.5 Реальные плавающие типы

П.1

Когда с тип float конвертируется в double или long double, или double конвертирован в long double, то его значение должно быть неизменяемо.

Англ.: « When a float is promoted to double or long double, or a double is promoted to long double, its value is unchanged.

(Тест 8.22, 8.23)

Закон:

П.2

Когда double понижен к float, или long double понижен к double или float, или значение, представляемое в большей точности и диапазоне чем требуемый его семантический тип (см. 6.3.1.8) явно преобразован(конвертирован) к его семантическому типу, если значение, являющееся преобразованный(конвертированный) может быть представлен точно в новом типе, это неизменяемо. Если значение, являющееся преобразованным(конвертированным) находится в диапазоне значений, которые могут быть представлены, но не могут быть представлены точно, результат является или самым близким выше или самое близкое более низкое перепрезентабельное значение, выбранное в определенной выполнением манере. Если преобразовываемое (конвертированное) значение - вне диапазона значения, которые могут быть представлены, поведение, неопределенны.

Англ.: « When a double is demoted to float, a long double is demoted to double or float, or a value being represented in greater precision and range than required by its semantic type (see 6.3.1.8) is explicitly converted to its semantic type, if the value being converted can be represented exactly in the new type, it is unchanged. If the value being converted is in the range of values that can be represented but cannot be represented exactly, the result is either the nearest higher or nearest lower representable value, chosen in an implementation-defined manner. If the value being converted is outside the range of values that can be represented, the behavior is undefined.»

Тест (8.24 – 8.29 )

5.4.8 Обычные арифметические преобразования

Закон:

6.3.1.8 Обычные арифметические преобразования

При выполнении операций производится автоматическое преобразование типов, чтобы привести операнды выражений к общему типу или чтобы расширить короткие величины до размера целых величин, используемых в машинных командах. Выполнение преобразования зависит от специфики операций и от типа операнда или операндов.

При математических операциях конечным итогом которых является переменная типа float, все операнды других типов перед вычислением будут преобразованы в тип float. При присваивании переменной типа float значения переменной другого типа оно также будет преобразовано в тип float.

П.1

При обычной арифметике.

Если один из операндов long double то второй будет преобразован к нему же, если это не вызовет изменений области второго.

(Тест 9.01 – 9.03)

Если оба операнда имеют тот же самый тип, то никакое дальнейшее преобразование не необходимо.

(Тест 9.04, 9.05)

Иначе, если оба операнда имеют типы signed integer, или оба имеют unsigned integer, операнд с типом меньшего целочисленного конверсионного ранга преобразованный (конвертированный) к типу операнда с большим рангом.

(Тест 9.06 – 9.08)

Закон:

Иначе, если операнд, который имеет тип целого числа без знака, имеет ранг, больший или равняйтесь рангу типа другого операнда, тогда операнду с тип signed integer преобразован (конвертирован) к типу операнда с unsigned integer.

(Тест 9.09, 9.10)

Закон:

Иначе, если тип операнда с типом signed integer может представлять все значения типа операнда с типом unsigned integer, тогда операнд с типом unsigned integer преобразован (конвертирован) к типу операнд с типом целого числа со знаком.

(Тест 9.11)

Закон:

П.2.

Значения float и результатов плавающих выражений могут быть представленный в большей точности и диапазоне чем требуемое типом; типы – нет измененный.

(Тест 9.12, 9.13)

5.4.9 Указатели

Закон:

6.3.2.3 Указатели

Указатель - это адрес памяти, распределяемой для размещения идентификатора (в качестве идентификатора может выступать имя переменной, массива, структуры, строкового литерала). В том случае, если переменная объявлена как указатель, то она содержит адрес памяти, по которому может находится скалярная величина любого типа. При объявлении переменной типа указатель, необходимо определить тип объекта данных, адрес которых будет содержать переменная, и имя указателя с предшествующей звездочкой (или группой звездочек). Формат объявления указателя:

спецификатор-типа [ модификатор ] * описатель .

Спецификатор-типа задает тип объекта и может быть любого основного типа.

П.2

Для любого спецификатора q, указатель на тип non-q-qualified может быть преобразован (конвертирован) к указателю на Q-квалифицированная версия типа; значения, сохраненные в первоначальных и преобразованных(конвертированных) указателях сравнится равный.

Англ.: « For any qualifier q, a pointer to a non-q-qualified type may be converted to a pointer to

the q-qualified version of the type; the values stored in the original and converted pointers shall compare equal.»

Т.е. когда константа 0, то она распознается как указатель, преобразуется компиляторов в нулевой указатель. Т.е. если во время инициализации, присваивания или сравнения с одной стороны стоит переменная или выражение имеющая тип указателя, компилятор решает, что константа 0 с другой стороны должна превратится в нулевой указатель.

char *p = 0;

if(p == 0) if(p != 0)

#define NULL ((void *)0)

FILE *fp = NULL;

Эти утверждения проверенны в (Тест 10.01 – 10.03).

Закон:

П.4

Преобразование нулевого(пустого) указателя на другой тип указателя уступает нулевого указатель того типа. Любые два нулевых указателя должны сравниться равный.

Англ.: « Conversion of a null pointer to another pointer type yields a null pointer of that type.

Any two null pointers shall compare equal.»

(Тест 10.04)

Закон:

П.6

Любые типы указателя могуть быть преобразован к целочисленному типу. Если результат не может быть представлен в целочисленном типе, поведение неопределенно.

Англ.: « Any pointer type may be converted to an integer type. Except as previously specified, the

result is implementation-defined. If the result cannot be represented in the integer type, the behavior is undefined. The result need not be in the range of values of any integer type.»

6 ПРИМЕРА 2 программа фрагментирует x +++++ y, проанализирован как x ++ ++ + y, который нарушает ограничение на операторы приращения, даже при том, что синтаксический анализ x ++ + ++ y мог бы выдавать(уступать) правильное выражение.

(Тест 10.05, 10.06)

5.4.10 Ключевые слова.

Закон:

6.4.1 Ключевые слова

П. 1 и 2

auto, break, case, char, const, continue, default, do, double, else, enum, extern, float, for, goto, if, inline, int, long, register, restrict, return, short, signed, sizeof, static, struct, switch, typedef, union, unsigned, void, volatile, while, _Bool, _Complex, _Imaginary

вышеупомянутые лексемы(маркеры) (зависимый от регистра) сохранены (в стадиях трансляции 7 и 8) для использования как ключевые слова и не должны использоваться иначе.

Т.е. присвоить этим зарегистрированным именам, какое либо значение, компилятор должен выдать ошибку. У зарегистрированных типов должен быть учтен регистр.

(Тест 10.07, 10.08)

Закон:

П.2

Идентификатор - последовательность символов нецифры (включая символ подчеркивания _ , нижний регистр и латинские символы верхнего регистра, и другие символы) и цифры, который определяет один или большее количество объектов как описано в 6.2.1. Нижний регистр и прописные буквы отличны.

Не имеется никакого определенного предела на максимальной длине идентификатора.

Т.е. проверить на все возможные имена идентификаторов, проверить максимум на длину имени.

Тест(10.09, 10.10)

Закон:

П.3

Начальный символ не должен быть универсальное символьное название(имя), обозначающее цифру.

Идентификатор не должен начинаться с цифры.

Тест(10.11)

Закон:

6.4.2.2 Предопределенные идентификаторы

П.1

Идентификатор _ _func_ _ должен быть неявно объявлен переводчиком как будто,

немедленно после открывающейся фигурной скобки каждого функционального определения, декларации

static const char _ _func_ _[] = "function-name";

Появился, где имя функции - название(имя) функции 60) lexically-прилагающего)

2 Этих название(имя) закодировано, как будто неявная декларация была написана в источнике набор символов и затем переведенный в набор символов выполнения как обозначено в трансляции стадия 5.

3 ПРИМЕР Рассматривает фрагмент кода:

#include

void myfunc(void)

{printf("%s\n", _ _func_ _);

/* ... */

}

Каждый раз функция называется, это будет печатать на стандартный выходной поток: Myfunc

60) Так как имя _ _func_ _ сохранено для любого использования выполнением (7.1.3), если любой другой идентификатор явно объявлен, используя название(имя) _ _func_ _, поведение неопределенно.

Тест (10.12)

Закон:

6.4.4.1 Целочисленные константы

П.1

Шестнадцатерично - префиксный: один из 0x 0X

Отличная от нуля цифра: один из 1 2 3 4 5 6 7 8 9

Восьмеричная цифра: один из 0 1 2 3 4 5 6 7

Шестнадцатеричная цифра: один из

0 1 2 3 4 5 6 7 8 9

a b c d e f

A B C D E F

Проверить значения с прекфиском 0х является шестнадцатеричным.

Тест (11.01, 11.02)

Проверить равенство цифр 1,2,3,4,5,6,7,8,9 отличных от 0.

Тест(11.03, 11.04)

Закон:

П.2

Целочисленная константа начинается с цифры, но не имеет никакого точки или части образца. Это может иметь префикс, который определяет основу и суффикс который определяет тип.

Англ: « An integer constant begins with a digit, but has no period or exponent part. It may have a

prefix that specifies its base and a suffix that specifies its type.»

(Тест 11.05)

Закон:

П.3

Десятичная константа начинается с цифры отличный от нуля и состоит из последовательности десятичного числа цифры. Восьмеричная константа состоит из префикса 0 произвольно сопровождаемый последовательностью цифры только 0 до 7. Шестнадцатеричная константа состоит из префикса 0x или сопровождаемого 0X последовательностью десятичных цифр и символов (или A) через f (или F) со значениями 10 до 15 соответственно.

(Тест 11.06 -11.09)

Закон:

П.4

Значение десятичной константы вычислено основа 10; таковой восьмеричной константы, базируйтесь 8; Таковой шестнадцатеричной константы, базируйтесь 16. Лексически первая цифра наиболее существенна.

(Тест 11.10 )

5.4.11 Комментарии

6.4.9 Комментарии

П.1

Комментарии обозначаются символом « /»

" // b " // четырех-символьный натягивают литерал

#include " // e " // неопределенное поведение

// */ // комментарий, не ошибка синтаксиса

f = g/ ** // h; // эквивалент f = g / h;

//\

i (); // часть комментария с двумя линиями

/\

/ J (); // часть комментария с двумя линиями

#define glue(x, y) x##y

glue (/, /) k (); // ошибка синтаксиса, не комментируют

/* //*/ l (); // эквивалент l ();

m = n // **/o

+ P; // эквивалент m= n + p;

69) Таким образом, /* ... */ комментарии не вкладывают.

(Тест 11.11 – 11.13)

5.4.12 Выражения

6.5 Выражения

«Выражение» это комбинация операнов и операторов, которая в результате имеет единственное значение.

«Операнд» это постоянное или переменное значение, которым манипулирует выражение. Каждый операнд в выражении это тоже, в свою очередь, выражение, т.к. он представляет собой отдельное значение. При вычислении значения результирующая величина зависит от порядка следования операторов в выражении, "последовательностей точек" и "побочных эффектов", если они есть. Порядок следования операторов определяет их группирование при вычислении значения выражения. Побочные эффекты это изменения, которые вызваны вычислением выражения. В выражении с побочными эффектами вычисление одного операнда может повлиять на значение другого. Для некоторых операторов порядок вычисления операндов также сказывается на значении всего выражения.

«Операторы» задают способ манипулирования операндом или операндами в выражении.

П.2

Между предыдущей и следующей последовательностью указывают объект, который должен иметь его сохраненное значение измененный самое большее однажды оценкой выражения. Кроме того, предшествующее значение будет только для чтения, чтобы определить значение, которое будет сохранено 70)

70) Этот параграф дает неопределенные операторные выражения типа

i = ++ i + 1;

a[ i ++] = i;

При разрешении

i = i + 1;

a[i] = i;

Англ: «Between the previous and next sequence point an object shall have its stored value modified at most once by the evaluation of an expression. Furthermore, the prior value shall be read only to determine the value to be stored.70)»

Тест 11.16 // правильный тест

#include

#include

#include

void main_11_16(void)

{ signed int i, a[2];

i=2;

i = i + 1;

if (i==3) { printf("\n Ok "); } else { printf("\n False "); };

a[i] = i;

printf("\n Ok ");

}

(Тест 11.14 – 11.16)

Началоsigned int i=2КонецРис. 27 Использование оператора инкремента i = i + 1Выводится сообщение «Ok» a [i] = i i < 0Выводится сообщение «False»НЕТДА

Блок схема тест программы 11.16 изображена на рис. 27.

В языке СИ допускается префиксная или постфиксная формы операций увеличения (уменьшения), поэтому значения выражения, использующего операции увеличения (уменьшения) зависит от того, какая из форм указанных операций используется.

Если знак операции стоит перед операндом (префиксная форма записи), то изменение операнда происходит до его использования в выражении и результатом операции является увеличенное или уменьшенное значение операнда.

В том случае если знак операции стоит после операнда (постфиксная форма записи), то операнд вначале используется для вычисления выражения, а затем происходит изменение операнда.

(Тест 11.17, 11.18)

5.5 Результаты тестирования компилятора

Результаты тестирования компилятора языка программирования С приведены в таблице. Эта таблица составлялась по схеме рис. 28.

Запуск тест-программыНа экран отобразились только «Ок»На экран отобразились только «False», при не правильном тестеНа экран отобразились «False» и «Ок»Тест пройден(+)Тест пройден (+)Тест не пройден (+/-)Рис. 28. Результаты тестирования Результат тестовНа экран отобразились «Error…» (ошибка компилятора) или «False» при правильном тестеТест не пройден (-)Анализ, исправление.Занесение результатов в таблицу тестов

Таблица 1

Тест	Результаты тестирования
Компилятор СКРВ Багет 2.0	Результат
1.01 1.02 1.03 1.04 1.05 1.06 1.07 1.08 1.09 1.10 1.11 1.12 1.13 1.14 1.15 1.16 1.17 1.18 1.19 1.20 1.21 1.22 1.23 1.24	Ok False Ok False Ok False Ok False Ok False Ok False Ok False Ok False Ok False Ok False Ok False Ok False	+ - + - + - + - + - + - + - + - + - + - + - + -
2.01 2.02 2.03 2.04 2.05 2.06 2.07 2.08 2.09 2.10 2.11 2.12 2.13 2.14 2.15 2.16 2.17 2.18 2.19 2.20 2.21 2.22 2.23 2.24 2.25 2.26 2.27 2.28 2.29 2.30 2.31 2.32 2.33 2.34 2.35	False Ok Two or more data types in declaration of Ok, underflow (ошибка переполнения) Ok, False Two or more data types in declaration of Two or more data types in declaration of Ничего не выдал Two or more data types in declaration of Two or more data types in declaration of Ничего не выдал Two or more data types in declaration of Two or more data types in declaration of Ok, False Two or more data types in declaration of Two or more data types in declaration of Ничего не выдал Ничего не выдал Two or more data types in declaration of Two or more data types in declaration of Two or more data types in declaration of Two or more data types in declaration of Ничего не выдал Ничего не выдал Two or more data types in declaration of Two or more data types in declaration of Two or more data types in declaration of Two or more data types in declaration of Ok, DDDD flat 52 else Two or more data types in declaration of Two or more data types in declaration of False Two or more data types in declaration of Two or more data types in declaration of «Epsilon»	- + - + +/- - - - - - - - - +/- - - - - - - - - - - - - - - + - - - - - -
3.01 3.02 3.03 3.04 3.05 3.06 3.07 3.08 3.09 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 3.20 3.21 3.22 3.23 3.24	Ok False False Undeclarator i Undeclarator i Ошибка 1, y - undeclarator Two or more data types in declaration of Undeclarator y Undeclarator y False Undeclarator i Undeclarator ii, iii Ok Ok Ok(4) Ok, Ok Ok, Ok Ok, Ok Ok, Ok Ok, Ok Warning: unused variable i, ii Ok(2) False False	+ + + + + + - + + + + - + + + + + + + + + + - +/-
4.01 4.02 4.03 4.04 4.05 4.06 4.07 4.08 4.09 4.10 4.11 4.12	Ошибка в объявлении float Two or more data types in declaration of Two or more data types in declaration of Ошибка 1, Two or more data types in declaration of Two or more data types in declaration of Two or more data types in declaration of Two or more data types in declaration of Two or more data types in declaration of Two or more data types in declaration of Two or more data types in declaration of Two or more data types in declaration of Two or more data types in declaration of	- - - - - - - - - - - -
5.01 5.02 5.03 5.04 5.05 5.06 5.07 5.08 5.09 5.10 5.11 5.12 5.13 5.14 5.15 5.16 5.17 5.18 5.19 5.20 5.21 5.22 5.23 5.24 5.25	Ошибка, coparison between pointer Переполнение Переполнение Comparison is always o dye to limited range of data type Ok Subsripted value is neithen array nor pointer assingnment makes integer from pointer without a cast parse a - undeclaration incompatible types is assigment, ошибка 1 Ok Return type defaults to int s - undeclaration Pi – used prior to declaration Ok uni Ok no uni String of character constant String of character constant Ok(2) declaration of “i” Ок False Ok Ok(2) Ok Ok	- - - - + - - + + + + - + + + - - + - + - + + + +
6.01 6.02 6.03 6.04 6.05 6.06 6.07 6.08 6.09 6.10 6.11 6.12 6.13 6.14 6.15 6.16 6.17 6.18 6.19 6.20	Ok(2) Ok Ok(4) Ok(5) Ok(2) Ok(6) Ok(5) Ok(5) Ok(4) Ok(5) Ok(5) Ok, Ok False(4) Ok(3) Ok(3) Ok False Ok q, t might be used uninitializein this fuction	+ + + + + + + + + + + Висит + - + + + - + -
7.01 7.02 7.03 7.04 7.05 7.06 7.07 7.08 7.09 7.10 7.11 7.12 7.13 7.14 7.15 7.16 7.17 7.18 7.19 7.20 7.21 7.22 7.23 7.24 7.25 7.26 7.27 7.28 7.29 7.30 7.31 7.32 7.33 7.34 7.35 7.36 7.37 7.38 7.39 7.40 7.41 7.42 7.43 7.44 7.45 7.46 7.47 7.48 7.49 7.50	Ok Ok Ok(3) Ok(4) Ok(2) Ok(6) Ok(4) Ok(2) Ok(5) Ok(4) Ok(2) Ok(5) Ok(4) Ok(2) Ok(5) Ok(4) Ok(2) Ok(5) Ok(4) Ok(2) Ok(5) Ok(5) Ok(5) Two or more data types in declaration of Ok(5) Two or more data types in declaration of False(3) False(3) False(3) Ok, False(2) False(3) False(3) Ok Ok Ok Ok Ok Ok Ok(2) Ok(2) Ok(2) Ok(2) False(2) Ok(3) Ok(3) Ok(3) Ok(3) Ok(2) Ok(4) Ok(4)	+ + + + + + + + + + + + + + + + + + + + + + + - + - + + + + + + + + + + + + + + + + - + + + + + + +
8.01 8.02 8.03 8.04 8.05 8.06 8.07 8.08 8.09 8.10 8.11 8.12 8.13 8.14 8.15 8.16 8.17 8.18 8.19 8.20 8.21 8.22 8.23 8.24 8.25 8.26 8.27 8.28 8.29	Ok(4) Ok(2) Ok(4) Ok(2) Ok(4) Ok(4) _Bool - undeclaration Ok, Ok Ok(2) False, False Ok, False Ok, False Ok(3) Ok(2) Ok(2) Ok(2) Ok(2) Two or more data types in declaration of Two or more data types in declaration of Two or more data types in declaration of Two or more data types in declaration of Two or more data types in declaration of Two or more data types in declaration of Two or more data types in declaration of Two or more data types in declaration of Two or more data types in declaration of Two or more data types in declaration of Two or more data types in declaration of Two or more data types in declaration of	+ + + + + + - + + - +/- +/- + + + + + - - - - - - - - - - - -
9.01 9.02 9.03 9.04 9.05 9.06 9.07 9.08 9.09 9.10 9.11 9.12 9.13	Two or more data types in declaration of Two or more data types in declaration of Two or more data types in declaration of Ok(8) Ok(8) Ok(8) Ok, False Two or more data types in declaration of li undeclaration Invalid lvalue in assignmount Ok (8) Invalid lvalue in assignmount Two or more data types in declaration of	- - - + + + +/- - - - + - -
10.01 10.02 10.03 10.04 10.05 10.06 10.07 10.08 10.09 10.10 10.11 10.12	Ok FILE – undeclaration, fp - undeclaration Ok, Ok Ok(2) Invalid lvalue in increment Parse error defore “,” Parse error defore “=” Ok Ok Nondigits is number and not hexadecimal parse error “_”- undeclaration	+ - + - Оши в указатели, exct + + + + + + + =/- (ошиб, не лог. станд )
11.01 11.02 11.03 11.04 11.05 11.06 11.07 11.08 11.09 11.10 11.11 11.12 11.13 11.14 11.15 11.16 11.17 11.18	Ok(4) Ok(4) Ok(8) Ok False Numeric conctant contains digits beyond the radix Ok Numeric conctant contains digits beyond the radix Ok Ok(3) Ok Ok(2) Parser error before “/” Invalid lvalue in increment Invalid lvalue in increment Ok(2) Ok(3) Ok(2)	+ + + + -(хотя может и +, см тест) + + + + + + + + + + + + +

Подведем итоги по таблице 1.

Успешно пройденные тесты: 155

Не пройденные тесты: 107

Из них:

Частично пройденные: 6

Тесты по несоотвествию типу dooble float (Two or more data types in declaration of): 52

Несоотвествие диапазону объявленных типов стандарта: 13

Программа подвесила систему: 1

Всего написано тестов 262.

Часть 2. Экология и охрана труда

Данный раздел дипломного проекта посвящен рассмотрению следующих вопросов:

спроектировать оптимальное рабочее место программиста, расчет естественное освещения.

Охрана труда - система обеспечения безопасности жизни и здоровья работников в процессе трудовой деятельности, включающая правовые, социально - экономические, организационно-технические, санитарно - гигиенические, лечебно - профилакти­ческие, реабилитационные и иные мероприятия.

Изучение и решение проблем, связанных с обеспеченностью здоровых и безопасных условий, в которых протекает труд человека одна из наиболее важных задач в разработке новых технологий и систем.

1.1 Разработка мероприятий, обеспечивающие оптимальное рабочее место программиста

Проектирование рабочих мест, снабженных видеотерминалами, относится к числу важнейших проблем эргономического проектирования в области вычислительной техники.

Рабочее место и взаимное расположение всех его элементов должно соответствовать антропометрическим, физическим и психологическим требованиям. Большое значение имеет также характер работы. В частности, при организации рабочего места программиста должны быть соблюдены следующие основные условия:

• оптимальное размещение оборудования, входящего в состав рабочего места;

• достаточное рабочее пространство, позволяющее осуществлять все необходимые движения и перемещения;

• необходимо естественное и искусственное освещение для выполнения поставленных задач;

• уровень акустического шума не должен превышать допустимого значения;

• достаточная вентиляция рабочего места.

Эргономическими аспектами проектирования видеотерминальных рабочих мест, в частности, являются: высота рабочей поверхности, размеры пространства для ног, требования к расположению документов на рабочем месте (наличие и размеры подставки для документов, возможность различного размещения документов, расстояние от глаз пользователя до экрана, документа, клавиатуры и т.д.), характеристики рабочего кресла, требования к поверхности рабочего стола, регулируемость рабочего места и его элементов.

Главными элементами рабочего места программиста являются письменный стол и кресло. Основным рабочим положением является положение сидя.

Рабочая поза сидя вызывает минимальное утомление программиста. Рациональная планировка рабочего места предусматривает четкий порядок и постоянство размещения предметов, средств труда и документации. То, что требуется для выполнения работ чаще, расположено в зоне легкой досягаемости рабочего пространства.

Моторное поле - пространство рабочего места, в котором могут осуществляться двигательные действия человека.

Максимальная зона досягаемости рук - это часть моторного поля рабочего места, ограниченного дугами, описываемыми максимально вытянутыми руками при движении их в плечевом суставе.

Оптимальная зона - часть моторного поля рабочего места, ограниченного дугами, описываемыми предплечьями при движении в локтевых суставах с опорой в точке локтя и с относительно неподвижным плечом.

рис.1 Зоны досягаемости рук в горизонтальной плоскости.

а - зона максимальной досягаемости;

б - зона досягаемости пальцев при вытянутой руке;

в - зона легкой досягаемости ладони;

г - оптимальное пространство для грубой ручной работы;

д - оптимальное пространство для тонкой ручной работы.

Рассмотрим оптимальное размещение предметов труда и документации в зонах досягаемости рук:

ДИСПЛЕЙ размещается в зоне а (в центре);

КЛАВИАТУРА - в зоне г/д;

СИСТЕМНЫЙ БЛОК размещается в зоне б (слева);

ПРИНТЕР находится в зоне а (справа);

ДОКУМЕНТАЦИЯ

в зоне легкой досягаемости ладони - в (слева) - литература и документация, необходимая при работе;

в выдвижных ящиках стола - литература, неиспользуемая постоянно.

При проектировании письменного стола следует учитывать следующее:

• высота стола должна быть выбрана с учетом возможности сидеть свободно, в удобной позе, при необходимости опираясь на подлокотники;

• нижняя часть стола должна быть сконструирована так, чтобы программист мог удобно сидеть, не был вынужден поджимать ноги;

• поверхность стола должна обладать свойствами, исключающими появление бликов в поле зрения программиста;

• конструкция стола должна предусматривать наличие выдвижных ящиков (не менее 3 для хранения документации, листингов, канцелярских принадлежностей, личных вещей).

Высота рабочей поверхности рекомендуется в пределах 680-760 мм. Высота рабочей поверхности, на которую устанавливается клавиатура, должна быть 650 мм.

Большое значение придается характеристикам рабочего кресла. Так, рекомендуется высота сиденья над уровнем пола должна быть в пределах 420-550 мм. Поверхность сиденья рекомендуется делать мягкой, передний край закругленным, а угол наклона спинки рабочего кресла - регулируемым.

Необходимо предусматривать при проектировании возможность различного размещения документов: сбоку от видеотерминала, между монитором и клавиатурой и т.п. Кроме того, в случаях, когда видеотерминал имеет низкое качество изображения, например заметны мелькания, расстояние от глаз до экрана делают больше (около 700 мм), чем расстояние от глаза до документа (300-450 мм). Вообще при высоком качестве изображения на видеотерминале расстояние от глаз пользователя до экрана, документа и клавиатуры может быть равным.

Положение экрана определяется:

- расстоянием считывания (0.60 + 0.10 м);

- углом считывания, направлением взгляда на 20 ниже горизонтали к центру экрана, причем экран перпендикулярен этому направлению.

Должна предусматриваться возможность регулирования экрана:

- по высоте +3 см;

- по наклону от 10 до 20 относительно вертикали;

- в левом и правом направлениях.

Зрительный комфорт подчиняется двум основным требованиям:

- четкости на экране, клавиатуре и в документах;

- освещенности и равномерности яркости между окружающими условиями и различными участками рабочего места;

Большое значение также придается правильной рабочей позе пользователя. При неудобной рабочей позе могут появиться боли в мышцах, суставах и сухожилиях. Требования к рабочей позе пользователя видеотерминала следующие: шея не должна быть наклонена более чем на 20 (между осью "голова-шея" и осью туловища), плечи должны быть расслаблены, локти - находиться под углом 80 - 100 , а предплечья и кисти рук - в горизонтальном положении. Причина неправильной позы пользователей обусловлена следующими факторами: нет хорошей подставки для документов, клавиатура находится слишком высоко, а документы - слишком низко, некуда положить руки и кисти, недостаточно пространство для ног. В целях преодоления указанных недостатков даются общие рекомендации: лучше передвижная клавиатура, чем встроенная; должны быть предусмотрены специальные приспособления для регулирования высоты стола, клавиатуры, документов и экрана, а также подставка для рук.

Характеристики используемого рабочего места:

- высота рабочей поверхности стола 750 мм;

- высота пространства для ног 650 мм;

- высота сиденья над уровнем пола 450 мм;

- поверхность сиденья мягкая с закругленным передним краем;

- предусмотрена возможность размещения документов справа и слева;

- расстояние от глаза до экрана 700 мм;

- расстояние от глаза до клавиатуры 400 мм;

- расстояние от глаза до документов 500 мм;

- возможно регулирование экрана по высоте, по наклону, в левом и в правом направлениях;

Очень важно чтобы установленный монитор соответствовал какому-либо стандарту по электромагнитной безопасности - MPRII или соответствующим требованиям TCO'92 или лучше ТСО`99. На монитор не должен падать прямой свет иначе образуются блики (если покрытие экрана не антибликовое). Глаза пользователя должны проецироваться на середину экрана (в слишком высоком или низком положении через некоторое время заболит шея или затылок).

1.2. Описание помещения, в котором располагается рабочее место.

Помещения с постоянным пребыванием людей должны иметь, как правило, естественное освещение. Естественное освещение подразделяется на боковое, верхнее и верхне-боковое (комбинированное). Установленные расчетом размеры световых проемов допускается изменять на +5, -10%.

Создание благоприятных условий труда и правильное эстетическое оформление рабочих мест на производстве имеет большое значение как для облегчения труда, так и для повышения его привлекательности, положительно влияющей на производительность труда. Окраска помещений и мебели должна способствовать созданию благоприятных условий для зрительного восприятия, хорошего настроения. В служебных помещениях, в которых выполняется однообразная умственная работа, требующая значительного нервного напряжения и большого сосредоточения, окраска должна быть спокойных тонов - малонасыщенные оттенки холодного зеленого или голубого цветов.

Помещение, в котором находится рабочее место оператора, имеет следующие характеристики:

- длина помещения 16 м;

- ширина помещения 6 м;

- высота 4 м;

- число окон 3;

- количество рабочих мест 3;

1.3. Расчет освещения рабочего места.

В помещении, где находится рабочее место оператора используется смешанное освещение, т.е. сочетание естественного и искусственного освещения. В качестве естественного - боковое освещение через окна.

Действующие нормы проектирования производственного освещения СНиП 23-05-95 устанавливают количественную и качественную характеристику освещения.

Искусственное освещение используется при недостаточном естественном освещении.

Расчет общего освещения осуществляется по методу светового потока с учетом потока, отраженного от стен и потолка.

Нормами для данных работ установлена необходимая освещенность рабочего места Ен=300лк (средняя точность работы по различению деталей размером от 1 до 10 мм). [СНиП-25-03-95]

Общий световой поток определяется по формуле:

(1.1)

где Ен - нормированная освещенность (Ен=300лк), т.к. разряд зрительных работ = 3;

S - площадь помещения;

z1 - коэффициент, учитывающий старение ламп и загрязнение светильников (z1=1.5);

z2 - коэффициент, учитывающий неравномерность освещения помещения (z2=1.1);

V - коэффициент использования светового потока; определяется в зависимости от коэффициентов отражения от стен, потолка, рабочих поверхностей, типов светильников и геометрии помещения.

Площадь помещения:

S= А * В = 16 * 6 = 96 м² . (1.2)

Выберем из таблицы [СниП 23.05.95 Нормы проектирования естественного освещения] коэффициент использования светового потока по следующим данным:

- коэффициент отражения побеленного потолка Rп=70%;

- коэффициент отражения от стен, окрашенных в светлую краску Rст=50%;

- коэффициент отражения от пола, покрытого линолеумом темного цвета Rp=10%;

- индекс помещения

(1.3)

Найденный коэффициент V=0.34. [СНиП-25-03-95]

По формуле (1.1) определяем общий световой поток

Для организации общего искусственного освещения выберем лампы типа ЛБ40.

Люминесцентные лампы имеют ряд преимуществ перед лампами накаливания: их спектр ближе к естественному; они имеют большую экономичность (больше светоотдача) и срок службы (в 10-12 раз). Наряду с этим имеются и недостатки: их работа сопровождается иногда шумом; хуже работают при низких температурах; их нельзя применять во взрывоопасных помещениях; имеют малую инерционность.

Для нашего помещения люминесцентные лампы подходят. Световой поток одной лампы ЛБ40 составляет не менее Fл=2810 лм.

Число N ламп, необходимых для организации общего освещения определяется по формуле

(1.4)

В качестве светильников выбираем ПВЛ-1, 2х40 Вт. Таким образом, чтобы обеспечить световой поток Fобщ=139764 лм надо использовать 25 светильников по 2 лампы ЛБ40 в каждом. Электрическая мощность одной лампы ЛБ40 Wл=40 Вт. Мощность всей осветительной системы

Wобщ = Wл * N = 40 * 50 = 2000 Вт. (1.5)

С целью снижения уровней засветки экранов мониторов прямыми световыми потоками светильников общего назначения последние следует располагать сбоку от рабочих мест, параллельно главной линии зрения операторов ПЭВМ и стене помещения с окнами. План размещения светильников в помещении изображен на рис. 2.

Вывод

В этой части дипломной работы были изложены требования к рабочему месту инженера - программиста. Созданные условия должны обеспечивать комфортную работу. На основании изученной литературы по данной проблеме, были указаны оптимальные размеры рабочего стола и кресла, рабочей поверхности, а также проведен выбор системы и расчет оптимального освещения производственного помещения. Соблюдение условий, определяющих оптимальную организацию рабочего места инженера - программиста, позволит сохранить хорошую работоспособность в течение всего рабочего дня, повысит как в количественном, так и в качественном отношениях производительность труда программиста, что в свою очередь будет способствовать быстрейшей разработке и последующему внедрению новой технологии производства.

Перечень основных нормативных документов, необходимых для оценки условий освещения

№№ п/п	Статус (ГОСТ, СН, СНиП, МУ и т. д.) и № документа, дата утверждения, ведомство	Наименование (полное)
1	СНиП 23—05—95, 02.08.95, Минстрой России	Строительные нормы и правила Российской Федерации. Естественное и искусственное освещение
2	Отраслевые (ведомственные) нормативные документы по искусственному освещению утверждены в разное время соответствующими министерствами и ведомствами	Отраслевые (ведомственные) нормы искусственного освещения предприятий различных отраслей промышленности, правила техники безопасности и производственной санитарии предприятий агропромышленного комплекса
3	ГОСТ 24940— 96,20.10.96, Минстрой России	Здания и сооружения. Методы измерения освещенности.
4	ГОСТ 26824—86, 30.01 .86, Госстрой СССР	Здания и сооружения. Методы измерения яркости
5	Р 2.2.013— 94, 12.07.94, Госкомсанэпиднадзор России	Гигиенические критерии оценки условий труда по показателям вредности и опасности факторов производственной среды, тяжести и напряженности трудового процесса
6	ГОСТ 17677—82, 29.06.87, Госстандарт СССР	Светильники, общие технические условия

Часть 3 Организационно-экономическая часть

1. Организация и планирование работ.

1.1 Назначение разработки.

Разрабатывается тест-программы для проверки соответствия компилятора С стандарту ANSI.

Данный тест-программы можно применять и для тестирования других версий или реализаций компилятора языка программирования С.

Данная работа является частью ОКР «ТестКомпил»

Заказчиком ОКР «ТестКомпил» является Министерство Обороны Российской Федерации (МО РФ).

Источником финансирования ОКР «ТестКомпил» является хоздоговор.

Исполнителями является группа разработчиков ГосНИИ АС.

В рамках договора исполнители обязуются выполнить данную задачу в срок и в полном объеме. Прием продукта осуществляет комиссия. Срок сдачи XII-2004 года.

1.2 Структура разработки.

В работе принимают участие:

1. Начальник сектора.

1. Инженер II категории.

2. Техник.

1.3 Этапы разработки.

1. Техническое задание.

2. Технические предложения.

3. Эскизно-технический проект.

1. Постановка задачи.

2. Разработка алгоритма.

3. Разработка программной реализации алгоритма.

4. Тестирование.

5. Предоставление продукта в готовом виде.

1. Сдача темы.

1.4 Ленточный график разработки.

этапы

1 (ТЗ)

2 (ТП)

3.1

3.2

3.3

3.4

3.5

4

5 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100 105 110 115 120 Дни

2. Стоимость разработки.

(Смета затрат)

2.1 Стоимость материалов, покупных изделий, полуфабрикатов.

№ п / п	Наименование материала	Количество	Цена за единицу, руб.	Сумма оплаты, руб.
1	Канцелярские товары	20	10	200
2	Бумага	100	1	100
3	Ватман	6	20	120
4	Гибкий носитель информации	5	15	75
5	Специальная литература	5	150	750
Итого по материалам:	1245

Транспортные расходы составляют 18,5% от стоимости материалов, т.е. 231 руб

Итого по статье: 1 476 руб.

2.2 Спецоборудование.

Спецоборудование для научных работ рассчитывается на основе заявок инженерных служб и прейскурантных цен на заказанное оборудование. Для разработки тест-программ спецоборудования не требуется.

2.3 Расчёт основной заработной платы.

№ п/п	Этап	Исполнитель	Трудоемкость, Дни	Оклад, руб/мес	Оплата, руб/ день	Оплата за этап, руб.
1	ТЗ	Нач. сектора Техник	5 5	7500 2000	340,9 90,9	1704,5 454,5
2	ТП	Нач. сектора Техник	10 15	7500 2000	340,9 90,9	3409 1363,5
3.1	Постановка Задачи	Нач. сектора Техник	10 15	7500 2000	340,9 90,9	3409 1363,5
3.2	Разработка Алгоритма	Нач. сектора Инженер IIкат. Техник	11 15 30	7500 5000 2000	340,9 227,27 90,9	3749,9 3409 2727
3.3	Разработка Программы	Инженер IIкат. Техник	15 30	5000 2000	227,27 90,9	3409 2727
3.4	Тестирование	Инженер IIкат. Техник.	10 10	5000 2000	227,27 90,9	2272,7 909
3.5	Готовый продукт	Нач. сектора Инженер IIкат. Техник	5 5 5	7500 5000 2000	340,9 227,27 90,9	1704,5 1136,4 454,5
4	Сдача темы (диплома)	Техник	2	2000	90,9	181,8
Основная заработная плата:	34 384,8

2.4 Расчёт дополнительной заработной платы.

Дополнительная заработная плата составляет 30% от основной заработной платы:

З _доп = З _осн *0,30= 34 384,8*0,30 = 10 315,44 руб.

2.5 Единый социальный налог.

ЕСН составляет 35,6% от суммы основной и дополнительной заработной платы: 44700,24*0,356=15 913,3 руб

2.6 Командировки

При выполнении данной разработки командировки не планируются.

2.7 Накладные расходы.

К накладным расходам относятся: заработная плата с отчислениями на социальное страхование административно-управленческого персонала, аренда помещения, использование материалов на хозяйственные нужды, почтово-телеграфные расходы, приобретение научной литературы и т. д. Сумма этих расходов планируется в процентах к сумме основной заработной платы исполнителей или к сумме прямых затрат.

В данном случае накладные расходы составляют 250 % от основной заработной платы, то есть составляют: 10 3154,4 руб.

2.8 Прочие производственные расходы.

К данным расходам относятся: затраты на подготовку специальной научно-технической информации, на аренду машинного времени, на проведение патентных исследований, научно-технических конкурсов и экспертиз, на услуги всех видов связи.

Расчет затрат на машинное время:

№	Вид работы	Применение ВТ	Требуемое машинное время в часах	Стоимость аренды 1 часа маш. врем. (руб.)	Стоимость маш. времени на тему (руб.)
1.	Перевод стандарта Ansi	IBM PC Pentium	250	54	13 500
2.	Написание тест-программ	IBM PC Pentium	188	40	7 520
3.	Оформление технического описания	IBM PC Pentium	90	20	1 800
Итого:	22 820

2.9 Смета затрат.

Статьи расходов	Сумма, руб.
Материалы, покупные изделия и полуфабрикаты	1 245
Спецоборудование для научных работ	----
Основная заработная плата	34 384,8
Дополнительная заработная плата	10 315,44
Единый социальный налог 35.6 %	15 913,3
Командировки	----
Накладные расходы	10 3154,4
Прочие производственные расходы	22 820
Итого:	187 832,04

Стоимость разработки - 187832,04 руб.

2.10 Расчет цены продукта.

Договорная цена складывается из стоимости разработки и норматива прибыли. Норматив прибыли составляет 30% от стоимости разработки, т.е. 56349,88 р.

Таким образом, договорная цена составляет:

Цена = 187 832,94 + 56 349,88 = 244 182,82 руб.

Цена с НДС = 244 182,82 * 18%=244182,82 + 43 952,9 = 288 135,72 руб.

3. Оценка экономической целесообразности проведения работ.

	Вероятность ошибки, баллы	Затраты трудовых ресурсов,баллы	Ценовой уровень, баллы	Технич. затраты, баллы	Время разработки, баллы
Свой образец (Россия)	5	6	8	8	10
Аналог (США)	9	10	6	10	5

Исходя из таблицы, можно сделать следующие выводы: по тем характеристикам, которые здесь представлены, тест-программы имеют свои аналоги, однако превосходит их по ряду параметров.

Таким образом, общий технический уровень проектируемых тест-программ выше технического уровня своего аналога. Из чего следует, что разрабатываемая система тест-программ экономически целесообразна.

4. Элементы бизнес-плана проекта.

4.1 Проектируемый продукт.

Проектируемый продукт представляет набор тест программ.

Может применяться в различных сферах человеческой деятельности, использующих средства передачи данных: авиационной, промышленной, информационной. Позволяя улучшить скоростные и надежностные характеристики средств передачи данных с одновременным уменьшением затрат на их изготовление.

4.2 Послепродажное обслуживание.

Организация послепродажного обслуживания будет включать в себя:

• бесплатный выпуск упущенных инструкций;

• организацию информационной поддержки пользователей (информирование пользователей об найденных ошибках, снабжение обновленными версиями программы, и т.д.);

организацию технической поддержки пользователей (служба технических консультантов).

Заключение

В данном дипломном проекте мною были исследованы и разработаны тест программы на языке программирования С, согласно стандарту ИСО 9899:1999 в части декларативных операторов.

Тестирование компилятора проводилась на машине с процессором intel под управлением операционной системой linux Red Hat 7.2. Результаты тестирования выявили несоответствия стандарту ИСО 9899:1999 С.

Список использованной литературы.

1. Стандарт ANSI ISO/IEC 9899:1999 en

2. Язык С. Б.В. Керниган, Д.М. Ричи

3. Майерс. Искусство тестирования программного обеспечения.

4. Майерс. Надежность программного обеспечения.

5. Кулаков. Управление качеством программного обеспечения.

6. Стандарт IEEE 829 Software Test Documentation

7. Э.Б. Самгин Освещение рабочих мест 1989г

8. Липаев В.В. «Тестирование программ», М. Радио и связь, 1986

ПРИЛОЖЕНИЕ

ЛИСТИНГИ программ

Проверка диапазонов декларативных операторов.

Текст программы «проверка диапазона char»:

Файл: 1.хх/01.cpp

Тест 1.01 // правильный тест signed char

#include

#include

#include

void main_1_01(void)

{ signed char i;

i=0; printf("\n i= %d ",i);

i=55; printf("\n i= %d ",i);

i=-55; printf("\n i= %d ",i);

i=127; printf("\n i= %d ",i);

i=-127; printf("\n i= %d ",i);

printf("\n Ok ");

Файл: 1.хх/02.cpp

Тест 1.02 // не правильный тест signed char

#include

#include

#include

void main_1_02(void)

{ signed char i;

i=555; printf("\n i= %d ",i);

i=-256; printf("\n i= %d ",i);

i=-255; printf("\n i= %d ",i);

i=255; printf("\n i= %d ",i);

printf("\n False ");

}

Файл: 1.хх/03.cpp

Тест 1.03 // правильный тест unsigned char

#include

#include

#include

void main_1_03(void)

{ unsigned char i;

i=0; printf("\n i= %d ",i);

i=55; printf("\n i= %d ",i);

i=255; printf("\n i= %d ",i);

i=10; printf("\n i= %d ",i);

printf("\n Ok ");

}

Файл: 1.хх/04.cpp

Тест 1.04 // не правильный тест unsigned char

#include

#include

#include

void main_1_04(void)

{ unsigned char i;

i=-1; printf("\n i= %d ",i);

i=-255; printf("\n i= %d ",i);

i=-55; printf("\n i= %d ",i);

i=500; printf("\n i= %d ",i);

printf("\n False ");

}

Текст программы «проверка диапазона short»:

Файл: 1.хх/05.cpp

Тест 1.05 // правильный тест signed short

#include

#include

#include

void main_1_05(void)

{ signed short i;

i=0; printf("\n i= %d ",i);

i=32767; printf("\n i= %d ",i);

i=370; printf("\n i= %d ",i);

i=-32767; printf("\n i= %d ",i);

i=-3200; printf("\n i= %d ",i);

printf("\n Ok ");

}

Файл: 1.хх/06.cpp

Тест 1.06 // не правильный тест signed short

#include

#include

#include

void main_1_06(void)

{ signed short i;

i=39000; printf("\n i= %d ",i);

i=32800; printf("\n i= %d ",i);

i=-3900; printf("\n i= %d ",i);

i=-32800; printf("\n i= %d ",i);

printf("\n False ");

}

Файл: 1.хх/07.cpp

Тест 1.07 // правильный тест unsigned short

#include

#include

#include

void main_1_07(void)

{ unsigned short i;

i=0; printf("\n i= %d ",i);

i=32800; printf("\n i= %d ",i);

i=535; printf("\n i= %d ",i);

i=65535; printf("\n i= %d ",i);

printf("\n Ok ");

}

Файл: 1.хх/08.cpp

Тест 1.08 // не правильный тест unsigned short

#include

#include

#include

void main_1_08(void)

{ unsigned short i;

i=-65535; printf("\n i= %d ",i);

i=-32800; printf("\n i= %d ",i);

i=65536; printf("\n i= %d ",i);

i=65800; printf("\n i= %d ",i);

printf("\n False ");

}

Текст программы «проверка диапазона short int»: (описано только в стандарте, в библиотеках нет)

Файл: 1.хх/09.cpp

Тест 1.09 // правильный тест signed short int

#include

#include

#include

void main_1_09(void)

{ signed short int i;

i=0; printf("\n i= %d ",i);

i=32767; printf("\n i= %d ",i);

i=370; printf("\n i= %d ",i);

i=-32767; printf("\n i= %d ",i);

i=-3200; printf("\n i= %d ",i);

printf("\n Ok ");

}

Файл: 1.хх/10.cpp

Тест 1.10 // не правильный тест signed short int

#include

#include

#include

void main_1_10(void)

{ signed short i;

i=39000; printf("\n i= %d ",i);

i=32800; printf("\n i= %d ",i);

i=-3900; printf("\n i= %d ",i);

i=-32800; printf("\n i= %d ",i);

printf("\n False ");

}

Файл: 1.хх/11.cpp

Тест 1. 11 // правильный тест unsigned short int

#include

#include

#include

void main_1_11(void)

{ unsigned short int i;

i=0; printf("\n i= %d ",i);

i=32800; printf("\n i= %d ",i);

i=535; printf("\n i= %d ",i);

i=65535; printf("\n i= %d ",i);

printf("\n Ok ");

}

Файл: 1.хх/12.cpp

Тест 1.12 // не правильный тест unsigned short int

#include

#include

void main_1_12(void)

{ unsigned short int i;

i=-65535; printf("\n i= %d ",i);

i=-32800; printf("\n i= %d ",i);

i=65536; printf("\n i= %d ",i);

i=65800; printf("\n i= %d ",i);

printf("\n False ");

}

Текст программы «проверка диапазона INT»:

Файл: 1.хх/13.cpp

Тест 1.13 // правильный тест signed int

#include

#include

void main_1_13(void)

{ signed int i;

i=0; printf("\n i= %d ",i);

i=32767; printf("\n i= %d ",i);

i=-500; printf("\n i= %d ",i);

i=-32767; printf("\n i= %d ",i);

i=500; printf("\n i= %d ",i);

printf("\n Ok ");

}

Файл: 1.хх/14.cpp

Тест 1.14 // не правильный тест signed int

#include

#include

void main_1_14(void)

{ signed int i;

i=53221; printf("\n i= %d ",i);

i=32800; printf("\n i= %d ",i);

i=-53221; printf("\n i= %d ",i);

i=-32800; printf("\n i= %d ",i);

printf("\n False ");

}

Файл: 1.хх/15.cpp

Тест 1.15 // правильный тест unsigned int

#include

#include

void main_1_15(void)

{ unsigned int i;

i=0; printf("\n i= %d ",i);

i=65535; printf("\n i= %d ",i);

i=500; printf("\n i= %d ",i);

i=1000; printf("\n i= %d ",i);

printf("n Ok ");

}

Файл: 1.хх/16.cpp

Тест 1.16 // не правильный тест unsigned int

#include

#include

void main_1_16(void)

{ unsigned int i;

i=-1; printf("\n i= %d ",i);

i=-32800; printf("\n i= %d ",i);

i=-658; printf("\n i= %d ",i);

i=65800; printf("\n i= %d ",i);

printf("\n False ");

}

Текст программы «проверка диапазона long int»: (описано только в стандарте, в библиотеках нет)

Файл: 1.хх/17.cpp

Тест 1.17 // правильный тест signed long int

#include

#include

void main_1_17(void)

{ signed long int i;

i=0; printf("\n i= %d ",i);

i=2147483647; printf("\n i= %d ",i);

i=370; printf("\n i= %d ",i);

i=-2147483647; printf("\n i= %d ",i);

i=-3200; printf("\n i= %d ",i);

printf("\n Ok ");

}

Файл: 1.хх/18.cpp

Тест 1.18 // не правильный тест signed long int

#include

#include

void main_1_18(void)

{ signed long int i;

i=2147483648; printf("\n i= %d ",i);

i=92147483640; printf("\n i= %d ",i);

i=-2147483648; printf("\n i= %d ",i);

i=-92147483640; printf("\n i= %d ",i);

printf("\n False ");

}

Файл: 1.хх/19.cpp

Тест 1.19 // правильный тест unsigned long int

#include

#include

void main_1_19(void)

{ unsigned long int i;

i=0; printf("\n i= %d ",i);

i=4294967295; printf("\n i= %d ",i);

i=370; printf("\n i= %d ",i);

i=2147483647; printf("\n i= %d ",i);

printf("\n Ok ");

}

Файл: 1.хх/20.cpp

Тест 1.20 // не правильный тест unsigned long int

#include

#include

#include

void main_1_20(void)

{ unsigned long int i;

i=-1; printf("\n i= %d ",i);

i=-92147483640; printf("\n i= %d ",i);

i=-2147483648; printf("\n i= %d ",i);

i=7483648; printf("\n i= %d ",i);

i=4294967296; printf("\n i= %d ",i);

printf("\n False ");

}

Текст программы «проверка диапазона long long int»: (описано только в стандарте, в библиотеках нет)

Файл: 1.хх/21.cpp

Тест 1.21 // правильный тест signed long long int

#include

#include

void main_1_21(void)

{ signed long long int i;

i=0; printf("\n i= %d ",i);

i=9223372036854775807; printf("\n i= %d ",i);

i=92233720368; printf("\n i= %d ",i);

i=-9223372036854775807; printf("\n i= %d ",i);

i=-922337203685; printf("\n i= %d ",i);

printf("\n Ok ");

}

Файл: 1.хх/22.cpp

Тест 1.22 // не правильный тест signed long long int

#include

#include

void main_1_22(void)

{ signed long long int i;

i=9223372036854775808; printf("\n i= %d ",i);

i=79223372036854775807; printf("\n i= %d ",i);

i=-9223372036854775808; printf("\n i= %d ",i);

i=-79223372036854775807; printf("\n i= %d ",i);

printf("\n False ");

}

Файл: 1.хх/23.cpp

Тест 1.23 // правильный тест unsigned long long int

#include

#include

void main_1_23(void)

{ unsigned long long int i;

i=0; printf("\n i= %d ",i);

i=18446744073709551615; printf("\n i= %d ",i);

i=370; printf("\n i= %d ",i);

i=2147483647; printf("\n i= %d ",i);

printf("\n Ok ");

}

Файл: 1.хх/24.cpp

Тест 1.1.24 // не правильный тест unsigned long long int

#include

#include

#include

void main_1_24(void)

{ unsigned long long int i;

i=-1; printf("\n i= %d ",i);

i=-18446744073709551615; printf("\n i= %d ",i);

i=-2147483648; printf("\n i= %d ",i);

i=7483648; printf("\n i= %d ",i);

i=18446744073709551616; printf("\n i= %d ",i);

printf("\n False ");

}

Тестирование типов с плавающей точкой.

Файл: 2.хх/01.cpp

Тест 2.01 // не правильный тест, демонстрирует переполнение

#include

#include

#include

void main_2_01(void)

{

int positive = 32767;

int negative = -32768;

printf("\n %d + 1 ravno %d\n ", positive,positive+1);

printf("\n %d - 1 ravno %d\n ", negative, negative-1);

printf("\n False ");

}

Присваивание типа Float, различные выражения.

Файл: 2.хх/02.cpp

Тест 2.02 // правильный тест float

#include

#include

#include

void main_2_02(void)

{ float i;

i=0; printf("\n i= %f ",i); // проверка работы с нулем

i=0E1; printf("\n i= %f ",i);

i=1E0; printf("\n i= %f ",i);

i=0E-1; printf("\n i= %f ",i);

i=-1E0; printf("\n i= %f ",i);

i=3.37E1; printf("\n i= %f ",i);

i=-3.37E1; printf("\n i= %f ",i);

i=1.17E-1; printf("\n i= %f ",i);

i=-1.17E-1; printf("\n i= %f ",i);

i=9.9E2; printf("\n i= %f ",i);

i=-9.9E2; printf("\n i= %f ",i);

i=9.9E-2; printf("\n i= %f ",i);

i=-9.9E-2; printf("\n i= %f ",i);

i=9.99999999E3; printf("\n i= %f ",i); //проверка использования разрядов по максимуму у мантиссы

i=-9.99999999E3; printf("\n i= %f ",i);

i=9.99999999E-3; printf("\n i= %f ",i);

i=-9.99999999E-3; printf("n i= %f ",i);

i=0.37E5; printf("\n i= %f ",i);

i=-0.37E5; printf("\n i= %f ",i);

i=0.17E-5; printf("\n i= %f ",i);

i=-0.17E-5; printf("\n i= %f ",i);

i=3.37E38; printf("\n i= %f ",i);

i=-3.37E38; printf("\n i= %f ",i);

i=1.17E-38; printf("\n i= %f ",i); // минимальное значение близкое к нулю

i=-1.17E-38; printf("\n i= %f ",i); // минимальное значение близкое к нулю

printf("\n Ok ");

}

Файл: 2.хх/03.cpp

Тест 2.03 // не правильный тест float

#include

#include

#include

void main_2_03(void)

{ float i;

i=0E100; printf("\n i= %f ",i);

i=1E100; printf("\n i= %f ",i);

i=0E-100; printf("\n i= %f ",i);

i=-1E100; printf("\n i= %f ",i);

i=3.37E1.5; printf("\n i= %f ",i);

i=-3.37E1.5; printf("\n i= %f ",i);

i=1.17E-1.5; printf("\n i= %f ",i);

i=-1.17E-1.5; printf("\n i= %f ",i);

// проверка использования разрядов по максимуму у мантиссы

i=9.9999999977E3; printf("\n i= %f ",i);

i=-9.9999999977E3; printf("\n i= %f ",i);

i=9.9999999977E-3; printf("\n i= %f ",i);

i=-9.9999999977E-3; printf("\n i= %f ",i);

i=0.37E50; printf("\n i= %f ",i);

i=-0.37E50; printf("\n i= %f ",i);

i=0.17E-50; printf("\n i= %f ",i);

i=-0.17E-50; printf("\n i= %f ",i);

i=3.37E39; printf("\n i= %f ",i); //превышение по степени

i=-3.37E39; printf("\n i= %f ",i);

i=1.17E-39; printf("\n i= %f ",i); // минимальное значение близкое к нулю

i=-1.17E-39; printf("\n i= %f",i); // минимальное значение близкое к нулю

i=3.9E38; printf("\n i= %f ",i); // превышение по значению мантисы

i=-3.9E38; printf("\n i= %f ",i);

i=1.9E-38; printf("\n i= %f ",i); // минимальное значение близкое к нулю

i=-1.9E-38; printf("\n i= %f ",i); // минимальное значение близкое к нулю

printf("\n False ");

}

Файл: 2.хх/04.cpp

Тест 2.04 // правильный тест float, проверка нормализации

#include

#include

#include

void main_2_04(void)

{ float i;

i=0.37E38; printf("\n i= %f ",i);

i=-0.37E38; printf("\n i= %f ",i);

i=0.17E-38; printf("\n i= %f ",i);

i=-0.17E-38; printf("\n i= %f ",i);

i=0.00037E38; printf("\n i= %f ",i);

i=-0.00037E38; printf("\n i= %f ",i);

i=0.00017E-38; printf("\n i= %f ",i);

i=-0.00017E-38; printf("\n i= %f ",i);

i=37.037E37; printf("\n i= %f ",i);

i=-37.037E37; printf("\n i= %f ",i);

i=10.017E-37; printf("\n i= %f ",i);

i=-10.017E-37; printf("\n i= %f ",i);

i=0.000037; printf("\n i= %f ",i);

i=-0.000037; printf("\n i= %f ",i);

printf("\n Ok ");

}

Файл: 2.хх/05.cpp

Тест 2.05// найдем максимальное количество разрядов мантиссе float и одновременно проверим соответствие стандарту

#include

void main_2_05(void)

{ float f;

f=0.1e38; printf("\n 1razryd ");

f=0.11e38; printf("\n 2razryd ");

f=0.111e38; printf("\n 3razryd ");

f=0.1111e38; printf("\n 4razryd ");

f=0.11111e38; printf("\n 5razryd ");

f=0.111111e38; printf("\n 6razryd standard ");

printf("\n Ok ");

f=0.1111111e38; printf("\n 7razryd ");

f=0.11111111e38; printf("\n 8razryd ");

printf("\n False ");

}

Файл: 2.хх/06.cpp

Тест 2.06 // найдем максимальное количество разрядов мантиссе double float и одновременно проверим соответствие стандарту

// naydem max kolvo razrydov mantise double float

#include

void main_2_06(void)

{ double float f;

f=0.1e308; printf("\n 1razryd ");

f=0.11e308; printf("\n 2razryd ");

f=0.111e308; printf("\n 3razryd ");

f=0.1111e308; printf("\n 4razryd ");

f=0.11111e308; printf("\n 5razryd ");

f=0.111111e308; printf("\n 6razryd ");

f=0.1111111e308; printf("\n 7razryd ");

f=0.11111111e308; printf("\n 8razryd standard ");

printf("\n Ok ");

f=0.111111111e308; printf("\n 9razryd ");

f=0.1111111111e308; printf("\n 10razryd ");

f=0.11111111111e308; printf("\n 11razryd ");

f=0.111111111111e308; printf("\n 12razryd ");

printf("\n False ");

}

Файл: 2.хх/07.cpp

Тест 2.07// найдем максимальное количество разрядов мантиссе long double float и одновременно проверим соответствие стандарту

#include

void main_2_07(void)

{ long double float f;

f=0.1e308; printf("\n 1razryd ");

f=0.11e308; printf("\n 2razryd ");

f=0.111e308; printf("\n 3razryd ");

f=0.1111e308; printf("\n 4razryd ");

f=0.11111e308; printf("\n 5razryd ");

f=0.111111e308; printf("\n 6razryd ");

f=0.1111111e308; printf("\n 7razryd ");

f=0.11111111e308; printf("n 8razryd standard ");

printf("\n Ok ");

f=0.111111111e308; printf("\n 9razryd ");

f=0.1111111111e308; printf("\n 10razryd ");

f=0.11111111111e308; printf("\n 11razryd ");

f=0.111111111111e308; printf("\n 12razryd ");

printf("\n False ");

}

Файл: 2.хх/08.cpp

Тест 2.08 // Найдем максимально возможное положительное значение мантиссы float

#include

void main_2_08(void)

{ float f; int i;

f=1.111111e38; i=0;

while (i=0)

{ printf("\n %d ", f);

f=f+0.0000001e38;

if (f==9.999999e38)

{printf("\n dostignuto 9.999999Е38 "); i=1; }

}

}

Файл: 2.хх/09.cpp

Тест 2.09 // Найдем максимально возможное положительное значение мантиссы double float

#include

void main_2_09(void)

{ double float f; int i;

f=1.1111111111e308; i=0;

while (i=0)

{ printf("\n %d ", f);

f=f+0.00000000001e308;

if (f==9.9999999999Е308 )

{printf("\n dostignuto 9.9999999999Е308 "); i=1; }

}

}

Файл: 2.хх/10.cpp

Тест 2.10 // Найдем максимально возможное положительное значение мантиссы long double float

#include

void main_2_10(void)

{ long double float f; int i;

f=1.1111111111e4932; i=0;

while (i=0)

{ printf("\n %d ", f);

f=f+0.00000000001e4932;

if (f==9.9999999999Е4932 )

{printf("\n dostignuto 9.9999999999Е4932 "); i=1; }

}

}

Файл: 2.хх/11.cpp

Тест 2.11 // Найдем максимально возможное положительное значение мантиссы float

#include

void main_2_11(void)

{ float f; int i;

f=-1.111111e38; i=0;

while (i=0)

{ printf("\n %d ", f);

f=f-0.0000001e38;

if (f==-9.999999e38)

{printf("\n dostignuto -9.999999Е38 "); i=1; }

}

}

Файл: 2.хх/12.cpp

Тест 2.12 // Найдем максимально возможное положительное значение мантиссы double float

#include

void main_2_12(void)

{ double float f; int i;

f=1.1111111111e308; i=0;

while (i=0)

{ printf("\n %d ", f);

f=f-0.00000000001e308;

if (f==-9.9999999999Е308 )

{printf("\n dostignuto -9.9999999999Е308 "); i=1; }

}

}

Файл: 2.хх/13.cpp

Тест 2.13 // Найдем максимально возможное положительное значение мантиссы long double float

#include

void main_2_13(void)

{ long double float f; int i;

f=-1.1111111111e4932; i=0;

while (i=0)

{ printf("\n %d ", f);

f=f-0.00000000001e4932;

if (f==-9.9999999999Е4932 )

{printf("=\n dostignuto -9.9999999999Е4932 "); i=1; }

}

}

Файл: 2.хх/14.cpp

Тест 2.14 // найдем максимальное количество разрядов степени float и одновременно проверим соответствие стандарту

#include

void main_2_14(void)

{ float f;

f=1e1; printf("\n 1razryd ");

f=1e11; printf("\n 2razryd standard ");

printf("\n Ok ");

f=1e111; printf("\n 3razryd ");

f=1e1111; printf("\n 4razryd ");

f=1e11111; printf("\n 5razryd ");

f=1e111111; printf("\n 6razryd ");

f=1e1111111; printf("\n 7razryd ");

printf("\n False ");

}

Файл: 2.хх/15.cpp

Тест 2.15 // найдем максимальное количество разрядов степени double float и одновременно проверим соответствие стандарту

#include

void main_2_15(void)

{ double float f;

f=1e1; printf("\n 1razryd ");

f=1e11; printf("\n 2razryd ");

f=1e111; printf("\n 3razryd standard ");

printf("\n Ok ");

f=1e1111; printf("\n 4razryd ");

f=1e11111; printf("\n 5razryd ");

f=1e111111; printf("\n 6razryd ");

f=1e1111111; printf("\n 7razryd ");

printf("\n False ");

}

Файл: 2.хх/16.cpp

Тест 2.16 // найдем максимальное количество разрядов степени long double float и одновременно проверим соответствие стандарту

#include

void main_2_16(void)

{ long double float f;

f=1e1; printf("\n 1razryd ");

f=1e11; printf("\n 2razryd ");

f=1e111; printf("\n 3razryd ");

f=1e1111; printf("\n 4razryd standard ");

printf("\n Ok ");

f=1e11111; printf("\n 5razryd ");

f=1e111111; printf("\n 6razryd ");

f=1e1111111; printf("\n 7razryd ");

f=1e11111111; printf("\n 8razryd ");

f=1e111111111; printf("\n 9razryd ");

printf("\n False ");

}

Файл: 2.хх/17.cpp

Тест 2.17 // Найдем максимально возможное положительное значение степени float

#include

void main_2_17(void)

{ float f; int i;

f=1e1; i=0;

while (i=0)

{ printf("\n %f ", f);

f=f*1e1;

if (f==1e99)

{printf("\n dostignuto 1Е99 "); i=1; }

}

}

Файл: 2.хх/18.cpp

Тест 2.18 // проверим соответствие стандарту максимальной степени float

#include

void main_2_18(void)

{ float f; int i;

f=1e1; i=0;

while (i=0)

{ printf("\n %f ", f);

f==f*1e1;

if (f=1e38)

{printf("\n standard "); i=1; }

}

}

Файл: 2.хх/19.cpp

Тест 2.19 // Найдем максимально возможное положительное значение степени double float

#include

void main_2_19(void)

{ double float f; int i;

f=1e38; i=0;

while (i=0)

{ printf("\n %d ", f);

f=f*1e1;

if (f==1e999)

{printf("\n dostignuto 1Е999 "); i=1; }

}

}

Файл: 2.хх/20.cpp

Тест 2.20// проверим соответствие стандарту степени double float

#include

void main_2_20(void)

{ double float f; int i;

f=1e38; i=0;

while (i=0)

{ printf("\n %d ", f);

f==f*1e1;

if (f=1e308)

{printf("\n standard "); i=1; }

}

}

Файл: 2.хх/21.cpp

Тест 2.21 // Найдем максимально возможное положительное степени мантиссы long double float

#include

void main_2_21(void)

{ long double float f; int i;

f=1e300; i=0;

while (i=0)

{ printf("\n %d ", f);

f=f*1e1;

if (f==1e9999)

{printf("\n dostignuto 1Е9999 "); i=1; }

}

}

Файл: 2.хх/22.cpp

Тест 2.22 // проверим соответствие стандарту степени long double float

#include

void main_2_22(void)

{ long double float f; int i;

f=1e300; i=0;

while (i=0)

{ printf("\n %d ", f);

f==f*1e1;

if (f=1e4932)

{printf("\n standard "); i=1; }

}

}

Файл: 2.хх/23.cpp

Тест 2.23 // Найдем максимально возможное отрицательное значение степени float

#include

void main_2_23(void)

{ float f; int i;

f=1e-1; i=0;

while (i=0)

{ printf("\n %d ", f);

f=f*1e-1;

if (f==1e-99)

{printf("\n dostignuto 1Е-99 "); i=1; }

}

}

Файл: 2.хх/24.cpp

Тест 2.24 // проверим соответствие стандарту степени float

#include

void main_2_24(void)

{ float f; int i;

f=1e-1; i=0;

while (i=0)

{ printf("\n %f ", f);

f==f*1e-1;

if (f=1e-38)

{printf("\n standard "); i=1; };

}

}

Файл: 2.хх/25.cpp

Тест 2.25 // Найдем максимально возможное отрицательное значение степени double float

#include

void main_2_25(void)

{ double float f; int i;

f=1e-38; i=0;

while (i=0)

{ printf("\n %d ", f);

f=f*1e-1;

if (f==1e-999)

{printf("\n dostignuto 1Е-999 "); i=1; }

}

}

Файл: 2.хх/26.cpp

Тест 2.26 // проверим соответствие стандарту степени double float

#include

void main_2_26(void)

{ double float f; int i;

f=1e-38; i=0;

while (i=0)

{ printf("\n %d ", f);

f==f*1e-1;

if (f=1e-308)

{printf("\n standard "); i=1; }

}

}

Файл: 2.хх/27.cpp

Тест 2.27// Найдем максимально возможное отрицательное значение степени long double float

#include

void main_2_27(void)

{ long double float f; int i;

f=1e-300; i=0;

while (i=0)

{ printf("\n %d ", f);

f=f*1e-1;

if (f==1e-999)

{printf("\n dostignuto 1Е-999 "); i=1; }

}

}

Файл: 2.хх/28.cpp

Тест 2.28 // проверим соответствие стандарту степени long double float

#include

void main_2_28(void)

{ long double float f; int i;

f=1e-300; i=0;

while (i=0)

{ printf("\n %d ", f);

f==f*1e-1;

if (f=1e-4932)

{printf("\n standard "); i=1; }

}

}

Файл: 2.хх/29.cpp

Тест 2.29 // различий между представлением с двойной и одинарной точностью

#include

#include

void main_2_29()

{ float accurate = 0.123456790987654321;

double more_accurate =0.1234567890987654321;

printf("\n znach. float\t %21.19f\n ",accurate);

// float 0.1234567890432815550

printf("\n znach. double\t %21.19f\n ", more_accurate);

// double 0.1234567890987654380

printf("\n Ok ");

}

Файл: 2.хх/30.cpp

Тест 2.30 // правильный тест, вычисления float EPSILON

#include

void main_2_30(void)

{ float EPSILON, eps, eps2, eps21;

eps = 1.0;

eps2 = eps * 0.5;

eps21 = eps2 + 1.0;

while( eps21 > 1.0 ){

eps = eps2;

eps2 = eps * 0.5;

eps21 = eps2 + 1.0;

}

else{ printf("\n float EPSILON= %f ", eps);}

}

Файл: 2.хх/31.cpp

Тест 2.31 // правильный тест, вычисления double float EPSILON

#include

#include

#include

void main_2_31(void)

{ double float EPSILON, eps, eps2, eps21;

eps = 1.0;

eps2 = eps * 0.5;

eps21 = eps2 + 1.0;

while( eps21 > 1.0 ){

eps = eps2;

eps2 = eps * 0.5;

eps21 = eps2 + 1.0;

} else { printf("\n double float EPSILON= %f ", eps);}

}

Файл: 2.хх/32.cpp

Тест 2.32 // правильный тест, вычисления long double float EPSILON

#include

#include

#include

void main(void)

{ long double float EPSILON, eps, eps2, eps21;

eps = 1.0;

eps2 = eps * 0.5;

eps21 = eps2 + 1.0;

while( eps21 > 1.0 ){

eps = eps2;

eps2 = eps * 0.5;

eps21 = eps2 + 1.0;

} else { printf("\n long double float EPSILON= %f ", eps);}

}

Файл: 2.хх/33.cpp

Тест 2.33 // правильный тест, соответствие стандарту float EPSILON

#include

#include

#include

void main_2_33(void)

{ float EPSILON;

EPSILON=9.53674316E-07;

if ((1.0+ EPSILON) == 1) { printf("\n Ok ");} else { printf("\n False ");}

}

Файл: 2.хх/34.cpp

Тест 2.34 // правильный тест, соответствие стандарту double float EPSILON

#include

#include

#include

void main(void)

{ double float EPSILON;

EPSILON= 2.2204460492503131E-16;

if ((1.0+ EPSILON) == 1) { printf("\n Ok ");} else { printf("\n False ");};

}

Файл: 2.хх/35.cpp

Тест 2.35 // правильный тест, соответствие стандарту long double float EPSILON

#include

#include

#include

void main_2_35(void)

{ long double float EPSILON;

EPSILON=1.084202172485504E-19;

if ((1.0+ EPSILON) == 1) { printf("\n Ok ");} else { printf("\n False ");};

}

Файл: 3.хх/01.cpp

Тест 3.01 // правильный тест

#include

#include

#include

void main_3_01(void)

{ signed int i=32767; unsigned int o=65535; signed long int q=2147483647;

unsigned long int w=4294967295; signed long long int e=9223372036854775807;

char r="list";

printf("\n %d ",i);

printf("\n Ok ");

}

Файл: 3.хх/02.cpp

Тест 3.02 // не правильный тест

#include

#include

#include

void main_3_02(void)

{ signed int i=32768; unsigned int o=65536; signed long int q=2147483648;

unsigned long int w=4294967296; signed long long int e=9223372036854775808;

printf("\n %d ",i);

printf("\n False ");

}

Файл: 3.хх/03.cpp

Тест 3.03 // не правильный тест

#include

#include

#include

void main_3_03(void)

{ signed int i= "list"; unsigned int o="list"; signed long int q="list";

unsigned long int w="list"; signed long long int e="list";

char r=-1;

printf("\n %d ",i);

printf("\n False ");

}

Файл: 3.хх/04.cpp

Тест 3.04 // не правильный тест, в начале идет идентификатор потом тип

#include

#include

#include

void main_3_04(void)

{ i= 8 signed int; o unsigned int ; q signed long int; r char;

printf("\n i=%d ",i);

printf("\n o=%d ",o);

printf("\n r=%d ",r);

printf("\n False ");

}

Файл: 3.хх/05.cpp

Тест 3.05 // не правильный тест, в начале идет идентификатор потом тип

#include

#include

#include

void main_3_05(void)

{ i= 8 signed int; o unsigned int ; q signed long int; r char;

printf("\n i=%d ",i);

printf("\n o=%d ",o);

printf("\n r=%d ",r);

printf("\n False ");

}

Файл: 3.хх/06.cpp

Тест 3.06 // не правильный тест, не правильная инициализации

#include

#include

#include

void main_3_06(void)

{ signed int i=44, a, unsigned int x,y=127;

printf("\n i=%d ",i);

a=20;

printf("\n a= %d ",a);

x=454;

printf("\n x= %d ",x);

printf("\n y= %d ",y);

printf("\n False ");

}

Файл: 3.хх/07.cpp

Тест 3.07 // правильный тест

#include

#include

#include

void main_3_07(void)

{ signed int i=44, a ; unsigned int x,y=127; float z=4.5E20; double float f=4.53E100; char c= «char»;

printf("\n i= %d ",i);

a=-200;

printf("\n a= %d ",a);

x=454;

printf("\n x= %d ",x);

printf("\n y= %d ",y);

printf("\n z= %d ",z);

printf("\n f= %d ",f);

printf("\n c= %d ",c);

printf("\n Ok ");

}

Файл: 3.хх/08.cpp

Тест 3.08 // не правильный тест

#include

#include

#include

void main_3_08(void)

{ signed int i=44.99, a ; unsigned int x,y=127.9999999;

printf("\n i= %d ",i);

a=-20.33;

printf("\n a= %d ",a);

x=-454;

printf("\n x= %d ",x);

printf("\n y= %d ",y);

printf("\n False ");

}

Файл: 3.хх/09.cpp

Тест 3.09 // не правильный тест

#include

#include

#include

void main_3_09(void)

{ signed char i= "44.99", a ; unsigned int x,y=127.9999999; char c=-3.9999999999;

printf("\n i= %d ",i);

a=-20.33;

printf("\n a= %d ",a);

x=-454;

printf("\n x= %d ",x);

printf("\n y= %d ",y);

printf("\n c= %d ",c);

printf("\n False ");

}

Файл: 3.хх/10.cpp

Тест 3.10 // не правильный тест signed char, без подключения библиотек

void main_3_10(void)

{ signed char i; signed int x; unsigned int y; float z;

i=0; printf("\n i= %d ",i);

x=-55; printf("\n x= %d ",x);

y=555; printf("\n y= %d ",y);

z=555; printf("\n z= %d ",z);

printf("\n False ");

}

Файл: 3.хх/11.cpp

Тест 3.11 // не правильный тест

#include

#include

#include

void main_3_11(void)

{ signed int i, a ; unsigned int a; float b;

i= 44.99; printf("\n i=%d ",i);

a=-20.33; printf("\n a= %d",a);

b= "rar"; printf("\n b= %d",b);

printf("\n False ");

}

Файл: 3.хх/12.cpp

Тест 3.12 // правильный тест

#include

#include

#include

void main_3_12(void)

{ signed int i=ii=iii=1, a ; float a=b=2;

printf("\n i=%d ",i); printf("\n ii=%d ",ii); printf("\n iii=%d ",iii);

printf("\n a=%d ",a); printf("\n b=%d ",b);

i=0; ii=5; i=ii=3;

printf("\n i=%d ",i); printf("\n ii=%d ",ii);

printf("\n Ok ");

}

Файл: 3.хх/13.cpp

Тест 3.13 // правильный тест

#include

#include

#include

void main_3_13(void)

{ float a1;

float b1;

int a, b, c;

char x, y; float z;

printf("\n Ok ");

}

Файл: 3.хх/14.cpp

Тест 3.14 // правильный тест

#include

#include

#include

void main_3_14(void)

{ char i;

if (1==sizeof(i)) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 3.хх/15.cpp

Тест 3.15 // правильный тест

#include

#include

#include

void main_3_15(void)

{ short i; int n; long l;

if (1<=sizeof(i)) { printf("\n Ok Ok "); } else { printf("\n False "); };

if (sizeof(i)<=sizeof(n)) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(n)<=sizeof(l)) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 3.хх/16.cpp

Тест 3.16// правильный тест

#include

#include

#include

void main_3_16(void)

{ float i; double n; long double l;

if (sizeof(i)<=sizeof(n)) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(n)<=sizeof(l)) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 3.хх/17.cpp

Тест 3.17 // правильный тест char

#include

#include

#include

void main_3_17(void)

{ char i; signed char n; unsigned char o;

if (sizeof(i)==sizeof(n)) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(n)==sizeof(o)) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 3.хх/18.cpp

Тест 3.18 // правильный тест short

#include

#include

#include

void main_3_18(void)

{ short i; signed short n; unsigned short o;

if (sizeof(i)==sizeof(n)) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(n)==sizeof(o)) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 3.хх/19.cpp

Тест 3.19 // правильный тест int

#include

#include

#include

void main_3_19(void)

{ int i; signed int n; unsigned int o;

if (sizeof(i)==sizeof(n)) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(n)==sizeof(o)) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 3.хх/20.cpp

Тест 3.20 // правильный тест long

#include

#include

#include

void main_3_20(void)

{ long i; signed long n; unsigned long o;

if (sizeof(i)==sizeof(n)) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(n)==sizeof(o)) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 3.хх/21.cpp

Тест 3.21 // не правильный тест

#include

#include

#include

void main_3_21(void)

{ const int i=0; const char ii=”con”;

i=i+1; con=con+"st";

printf("\n False ");

}

Файл: 3.хх/22.cpp

Тест 3.22 // правильный тест

#include

#include

#include

void main_3_22(void)

{ int octal_value = 0227; // 151

int hex_value = 0xFF0 ; //4080

if (octal_value ==151) { printf("\n Ok "); } else { printf("\n False ");};

if (hex_value ==4080) { printf("\n Ok "); } else { printf("\n False ");};

}

Файл: 3.хх/23.cpp

Тест 3.23 // не правильный тест, попытка деления на 0

#include

#include

#include

void main_3_23(void)

{ int x, y;

x=5;

y=x/0;

printf("\n False ");

}

Файл: 3.хх/24.cpp

Тест 3.24 // правильный тест

#include

#include

#include

void main_3_24(void)

{ int x, y;

x=5;

printf("\n False Koppilytor dolgen predupredit o ne ispolzuetsy ");

}

Арифметическая операция сложения с плавающем типов.

Файл: 4.хх/01.cpp

Тест 4.01 // тест сложения float

#include

#include

#include

void main_4_01(void)

{ float x, y, z;

x=1,7е5; printf("\n x= %f ",x);

y=2,3е5; printf("\n y= %f ",y);

z=x+y; printf("\n z=x+y= %f ",z);

z=y+z; printf("\n z=y+z= %f ",z);

if (z==4E5) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 4.хх/02.cpp

Тест 4.02 // тест сложения double float

#include

#include

#include

void main_4_02(void)

{ double float x, y, z;

x=1,7е307; printf("\n x= %f ",x);

y=2,3е307; printf("\n y= %f ",y);

z=x+y; printf("\n z=x+y= %f ",z);

z=y+z; printf("\n z=y+z= %f ",z);

if (z==4E307) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 4.хх/03.cpp

Тест 4.03 // тест сложения double float, заранее определяем результирующему идентификатору меньший диапазон(тип).

#include

#include

#include

void main_4_03(void)

{ double float x, y; float z;

x=1,7е307; printf("\n x= %f ",x);

y=2,3е307; printf("\n y= %f ",y);

z=x+y; printf("\n z=x+y= %f ",z);

z=y+z; printf("\n z=y+z= %f ",z);

f (z==4E307) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 4.хх/04.cpp

Тест 4.04 // тест сложения long double float, заранее определяем результирующему идентификатору меньший диапазон(тип).

#include

#include

#include

void main_4_04(void)

{ long double float x, y; float z;

x=1,7е3000; printf("\n x= %f ",x);

y=2,3е3000; printf("\n y= %f ",y);

z=x+y; printf("\n z=x+y= %f ",z);

z=y+z; printf("\n z=y+z= %f ",z);

if (z==4E3000) { printf("\n Ok "); } else { printf(\n False "); };

}

Файл: 4.хх/05.cpp

Тест 4.05 // тест сложения long double float, заранее определяем результирующему идентификатору меньший диапазон(тип).

#include

#include

#include

void main_4_05(void)

{ long double float x, y; double float z;

x=1,7е310; printf("\n x= %f ",x);

y=2,3е310; printf("\n y= %f ",y);

z=x+y; printf("\n z=x+y= %f ",z);

z=y+z; printf("\n z=y+z= %f ",z);

if (z==4E10) { printf("\n Ok "); } else { printf("\n False "); };

if ((x+y)==(y+x)) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 4.хх/06.cpp

Тест 4.06 // тест сложения long double float

#include

#include

#include

void main_4_06(void)

{ long double float x, y, z;

x=1,7е310; printf("\n x= %f ",x);

y=2,3е310; printf("\n y= %f ",y);

z=x+y; printf("\n z=x+y= %f ",z);

z=y+z; printf("\n z=y+z= %f ",z);

if (z==4E310) { printf("\n Ok "); } else { printf("\n False "); };

if ((x+y)==(y+x)) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 4.хх/07.cpp

Тест 4.07 // тест сложения

#include

#include

#include

void main_4_07(void)

{ float x, z; double float y;

x=1,7е38; printf("\n x= %f ",x);

y=2,3е40; printf("\n y= %f ",y);

z=x+y; printf("\n z=x+y= %f ",z);

z=y+z; printf("\n z=y+z= %f ",z);

if ((x+y)==(y+x)) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 4.хх/08.cpp

Тест 4.08 // тест сложения

#include

#include

#include

void main_4_08(void)

{ double float x, z; float y;

x=1,7е40; printf("\n x= %f ",x);

y=2,3е38; printf("\n y= %f ",y);

z=x+y; printf("\n z=x+y= %f ",z);

z=y+z; printf("\n z=y+z= %f ",z);

if ((x+y)==(y+x)) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 4.хх/09.cpp

Тест 4.09 // тест сложения

#include

#include

#include

void main_4_09(void)

{ double float x, z; long double float y;

x=1,7е307; printf("\n x= %f ",x);

y=2,3е310; printf("\n y= %f ",y);

z=x+y; printf("\n z=x+y= %f ",z);

z=y+z; printf("\n z=y+z= %f ",z);

if ((x+y)==(y+x)) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 4.хх/10.cpp

Тест 4.10 // тест сложения

#include

#include

#include

void main_4_10(void)

{ long double float x, z; double float y;

x=1,7е310; printf("\n x= %f ",x);

y=2,3е307; printf("\n y= %f ",y);

z=x+y; printf("\n z=x+y= %f ",z);

z=y+z; printf("\n z=y+z= %f ",z);

if ((x+y)==(y+x)) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 4.хх/11.cpp

Тест 4.11 // тест сложения

#include

#include

#include

void main_4_11(void)

{ float x, z; long double float y;

x=1,7е37; printf("\n x= %f ",x);

y=2,3е310; printf("\n y= %f ",y);

z=x+y; printf("\n z=x+y= %f ",z);

z=y+z; printf("\n z=y+z= %f ",z);

if ((x+y)==(y+x)) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 4.хх/12.cpp

Тест 4.12 // тест сложения

#include

#include

#include

void main_4_12(void)

{ long double float x, z; float y;

x=1,7е310; printf("\n x= %f ",x);

y=2,3е38; printf("\n y= %f ",y);

z=x+y; printf("\n z=x+y= %f ",z);

z=y+z; printf("\n z=y+z= %f ",z);

if ((x+y)==(y+x)) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 5.хх/01.cpp

Тест 5.01 // правильный тест в начале программы тип i signed int, в середине char

#include

#include

#include

void main_5_01(void)

{ signed int i;

i=32767; printf("\n i= %d ",i);

char i;

i= "tip char"; printf("\n i= %d ",i);

if (i =="tip char") { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 5.хх/02.cpp

Тест 5.02 // правильный тест в начале программы тип i char, в середине signed int

#include

#include

#include

void main_5_02(void)

{ char i;

i= "tip char"; printf("\n i= %d ",i);

signed int i;

i=32767; printf("\n i= %d ",i);

if (i ==32767) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 5.хх/03.cpp

Тест 5.03 // правильный тест в начале программы тип i char, в середине signed long long int

#include

#include

#include

void main_5_03(void)

{ char i;

i= "tip char"; printf("\n i= %d ",i);

signed long long int i;

i=9223372036854775807; printf("\n i= %d ",i);

if (i ==9223372036854775807) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 5.хх/04.cpp

Тест 5.04 // правильный тест в начале программы тип i char, в середине signed long long int

#include

#include

#include

void main_5_04(void)

{ char i;

i= "tip char"; printf("\n i= %d ",i);

signed short i;

i=922; printf("\n i= %d ",i);

if (i ==922) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 5.хх/05.cpp

Тест 5.05 // правильный тест в начале программы идентификатор i обозначает один объект, в конце другой.

#include

#include

#include

void main_5_05(void)

{ char i;

i= "tip char"; printf("\n i= %d ",i);

i= 7; printf("\n i= %d ",i);

if (i ==7) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 5.хх/06.cpp

Тест 5.06 // правильный тест в начале программы объявлен тип i char, в середине массив.

#include

#include

#include

void main_5_06(void)

{ char i;

i= "tip char"; printf("\n i= %d ",i);

int i[100];

i[7]=3;

printf("\n i[7]= %d ", i[7]);

if (i[7]==3) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 5.хх/07.cpp

Тест 5.07 // правильный тест в начале программы объявлен тип i char, в середин используется массив а, теперь идентификатору i присвоим другой объект.

#include

#include

#include

void main(void)

{ char i;

i= "tip char"; printf("\n i= %d ",i);

int t[100];

t[7]=3;

i= t[7];

printf("\n i= %d ", i);

if (i= t[7]) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 5.хх/08.cpp

Тест 5.08 // не правильный тест в начале программы объявлен тип i char, в середине используется массив, без объявления.

#include

#include

#include

void main_5_08(void)

{ char i;

i= "tip char"; printf("\n i= %d ",i);

a[7]=3;

printf("\n a[7]= %d ", a[7]);

printf("\n False ");

}

Файл: 5.хх/09.cpp

Тест 5.09 // не правильный тест массива

#include

#include

#include

void main_5_09(void)

{ int i[2][2] = { { 1,2 }, { 3 } };

i= "tip char"; printf("%n i= %d ",i);

i[7]=3;

printf("\n i[7]= %d ", i[7]);

printf("\n False ");

}

Файл: 5.хх/10.cpp

Тест 5.10// правильный тест, вывода чисел от 1 до 5

#include

void main_5_10(void)

{ int count = 1 ;

label: printf("\n %d ", count++);

if (count <= 5) goto label ; printf("\n Ok ");

}

Файл: 5.хх/11.cpp

Тест 5.11 // не правильный тест

#include

test1()

{ goto label ; }

test2()

{ label: printf("\n test2() "); printf("%n False ");};

void main(void)

{ test1();}

Файл: 5.хх/12.cpp

Тест 5.12 // правильный тест

#include

#include

#include

void main_5_12(void)

{ struct s { int i; const int ci; }; const float pi;

s.i=100;

s.ci=200;

printf("\n s.i=%d ", s.i);

pi=3,14;

printf("\n pi=%d ", pi);

printf("\n Ok ");

}

Файл: 5.хх/13.cpp

Тест 5.13 // не правильный тест

#include

#include

#include

void main_5_13(void)

{ pi=3,14; printf("\n pi=%d ", pi);

s.i=100;

struct s { int i; const int ci; }; const float pi;

s.ci=200;

printf("\n s.i=%d ", s.i);

printf("\n False ");

}

Файл: 5.хх/14.cpp

Тест 5.14 // без связи

#include

#include

#include

void main_5_14(void)

{ signed int i; unsigned int o;

i=32767; printf("\n i= %d ",i);

o=65535; printf("\n o= %d ",o);

if (o>i)

{

printf("\n Ok uni ");

}

else printf("\n False no uni ");

}

Файл: 5.хх/15.cpp

Тест 5.15 // правильный, со связью

#include

#include

#include

void main_5_15(void)

{ signed int i; unsigned int o;

i=32767; printf("\n ",i);

o=65535; printf("\n ",o);

o=i;

if (o<>i)

{

printf("\n False uni ");

}

else printf("\n Ok no uni ");

}

Файл: 5.хх/16.cpp

Тест 5.16 // правильный тест

#include

#include

#include

void main(void)

{ extern char i;

printf("\n %d", i);

printf("\n Ok ");

}

Файл: 5.хх/17.cpp

Тест 5.17// не правильный тест

#include

#include

#include

void main_5_17(void)

{ printf("\n %d", i);

extern char i;

printf("\n False ");

}

Файл: 5.хх/18.cpp

Тест 5.18 // правильный тест

#include

#include

#include

void main_5_18(void)

{ signed int i; unsigned int i;

i=32767; printf("\n i= %d ",i);

i=65535; printf("\n i= %d ",i);

printf("\n Ok ");

if (i== 65535) { printf("\n Ok "); } else { printf("\n False"); };

}

Файл: 5.хх/19.cpp

Тест 5.19 // не правильный тест

#include

#include

#include

void main_5_19(void)

{ signed int i; unsigned int i;

i=-32767; printf("\n i= %d ",i);

printf("\n False ");

}

Файл: 5.хх/20.cpp

Тест 5.20 // правильный тест

#include

#include

#include

void main_5_20(void)

{ float i;

i=32767; printf("\n i= %d ",i);

i=65535; printf("\n i= %d ",i);

printf("\n Ok ");

}

Файл: 5.хх/21.cpp

Тест 5.21 // не правильный тест

#include

#include

#include

void main_5_21(void)

{ unsigned int i;

i=-32767; printf("\n i= %d ",i);

printf("\n False ");

}

Файл: 5.хх/22.cpp

Тест 5.22 // правильный тест

#include

#include

#include

void main_5_22(void)

{ float i; float t;

printf("\n i= %d ",i);

t=1.4e4; printf("\n t= %d ",i);

i=1.4e6; printf("\n i= %d ",i);

printf("\n Ok ");

}

Файл: 5.хх/23.cpp

Тест 5.23 // правильный тест, в различных точках программы адрес идентификатор не должен меняться

#include

#include

#include

void main_5_23(void)

{ int i, adr1, adr2, adr3;

adr1=*i;

printf("\n adr1= %d ",adr1);

adr2=*i;

printf("\n adr2= %d ",adr2);

if (adr1===adr2) { printf("\n Ok "); } else { printf("\n False "); };

adr3=*i;

printf("\n adr3= %d ",adr3);

if (adr2==adr3) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 5.хх/24.cpp

Тест 5.24 // правильный тест

#include

#include

#include

void main_5_24(void)

{ int b[3];

b[1]=1;

b[2]=2;

b[3]=3;

printf("\n b[1]=%d ", b[1]);

printf("\n b[2]=%d ", b[2]);

printf("\n b[3]= %d ", b[3]);

printf("\n Ok ");

}

Файл: 5.хх/25.cpp

Тест 5.25 // правильный тест

#include

#include

#include

void main_5_25(void)

{ int b[3];

b[1]=1;

b[2]=2;

b[3]=3;

printf("\n b[1]=%d ", b[1]);

printf("\n b[2]=%d ", b[2]);

printf("\n b[3]= %d ", b[3]);

printf("\n b[4]= %d ", b[4]);

printf("\n Ok ");

}

Типы значений индентификаторов

Файл: 6.хх/01.cpp

Тест 6.01 // правильный тест

#include

#include

#include

void main_6_01(void)

{ char i;

i= "char";

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

i= "-50";

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 6.хх/02.cpp

Тест 6.02 // правильный тест, проверим могут ли быть объявлены эти типы

#include

#include

#include

void main_6_02(void)

{ short int i; signed short int q; unsigned short w; unsigned short int e; signed r; signed int t;

unsigned y; unsigned int u; long int o; signed long int p; unsigned long a; unsigned long int s;

long long int d; signed long long int f; unsigned long long g; unsigned long long int h;

printf("\n Ok ");

}

Файл: 6.хх/03.cpp

Тест 6.03 // правильный тест, short int i; signed short int q

#include

#include

#include

void main_6_03(void)

{ short int i; signed short int q;

i=-32767;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

if (i==-32767) { printf("\n Ok "); } else { printf("\n False "); };

q=-12;

if (q<0) { printf("\n Ok"); } else { printf("\n False "); };

if (q==-12) { printf("\n Ok "); } else { printf("\n False "); };

q=-32767;

if (q==i) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 6.хх/04.cpp

Тест 6.04 // правильный тест, unsigned short i; unsigned short int q;

#include

#include

#include

void main_6_04(void)

{ unsigned short i; unsigned short int q;

i=65535;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

if (i==65535) { printf("\n Ok "); } else { printf("\n False "); };

q=12;

if (q>0) { printf("\n Ok "); } else { printf("\n False "); };

if (q==12) { printf("\n Ok "); } else { printf("\n False "); };

q=65535;

if (q==i) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 6.хх/05.cpp

Тест 6.05 // не правильный тест, unsigned short i; unsigned short int q;

#include

#include

#include

void main_6_05(void)

{ unsigned short i; unsigned short int q;

i=-120;

q=-120;

if (i=-120) { printf("\n False "); } else { printf("\n Ok "); };

if (q=-120) { printf("\n False "); } else { printf("\n Ok "); };

}

Файл: 6.хх/06.cpp

Тест 6.06 // правильный тест, signed i; signed int q;

#include

#include

#include

void main_6_06(void)

{ signed i; signed int q;

i=-32767;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

if (i==-32767) { printf("\n Ok "); } else { printf("\n False "); };

q=-12;

if (q<0) { printf("\n Ok "); } else { printf("\n False "); };

if (q==-12) { printf("\n Ok"); } else { printf("\n False "); }

q=-32767;

if (q==i) { printf("\n Ok "); } else { printf("\n False "); }

}

Файл: 6.хх/07.cpp

Тест 6.07 // правильный тест, unsigned i; unsigned int q;

#include

#include

#include

void main_6_07)

{ unsigned int i; unsigned int q;

i=65535;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

if (i==65535) { printf("\n Ok "); } else { printf("\n False "); };

q=12;

if (q>0) { printf("\n Ok "); } else { printf("\n False "); };

if (q==12) { printf("\n Ok "); } else { printf("\n False "); };

q=65535;

if (q==i) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 6.хх/08.cpp

Тест 6.08 // правильный тест, long int i; signed long int q;

#include

#include

#include

void main(void)

{long int i; signed long int q;

i=-2147483647;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

if (i==-2147483647) { printf("\n Ok "); } else { printf("\n False "); };

q=-12;

if (q<0) { printf("\n Ok "); } else { printf("\n False "); };

if (q==-12) { printf("\n Ok "); } else { printf("\n False "); };

q=-2147483647;

if (q==i) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 6.хх/09.cpp

Тест 6.09 // правильный тест, unsigned long i; unsigned long int q;

#include

#include

#include

void main_6_09(void)

{ unsigned long i; unsigned long int q;

i=4294967295;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

if (i==4294967295) { printf("\n Ok "); } else { printf("\n False "); };

q=12;

if (q>0) { printf("\n Ok "); } else { printf("\n False "); };

if (q==12) { printf("\n Ok "); } else { printf("\n False "); };

q=4294967295;

if (q==i) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 6.хх/10.cpp

Тест 6.10 // правильный тест, long long int i; signed long long int q;

#include

#include

#include

void main_6_10(void)

{ long long int i; signed long long int q;

i=-9223372036854775807;

if (i<=0) { printf("\n Ok "); } else { printf("\n False "); };

if (i==-9223372036854775807) { printf("\n Ok "); } else { printf("\n False "); };

q=-12;

if (q<0) { printf("\n Ok"); } else { printf("\n False "); };

if (q==-12) { printf("\n Ok "); } else { printf("\n False "); };

q=-9223372036854775807;

if (q==i) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 6.хх/11.cpp

Тест 6.11 // правильный тест, unsigned long long i; unsigned long long int q;

#include

#include

#include

void main_6_11(void)

{ unsigned long long i; unsigned long long int q;

i=18446744073709551615;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

if (i==18446744073709551615) { printf("\n Ok "); } else { printf("\n False "); };

q=12;

if (q>0) { printf("\n Ok "); } else { printf("\n False "); };

if (q==12) { printf("\n Ok "); } else { printf("\n False "); };

q=18446744073709551615;

if (q==i) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 6.хх/12.cpp

Тест 6.12 // правильный тест, unsigned long i; unsigned long int q;

#include

#include

#include

void main_6_12(void)

{ signed char i; char q;

if (sizeof(i)==sizeof(q)) { printf("\%n Ok "); } else { printf("\n False "); };

i=-127;

q=-127;

if (i==q) { printf("\n Ok "); } else { printf("\n False "); }

}

Файл: 6.хх/13.cpp

Тест 6.13 // правильный тест, unsigned long i; unsigned long int q;

#include

#include

#include

void main_6_13(void)

{ signed int i; int q;

if (sizeof(i)==sizeof(q)) { printf("\n Ok "); } else { printf("\n False "); };

i=-32767;

q=-32767;

if (i==q) { printf("\n Ok "); } else { printf("%\n False "); };

}

Файл: 6.хх/14.cpp

Тест 6.14 // правильный тест

#include

#include

#include

void main_6_14(void)

{ unsigned int i;

i=65535*65535;

if (i>=65535) { printf("\n False "); } else { printf("\n Ok "); };

i=65535+65535;

if (i>=65535) { printf("\n False "); } else { printf("\n Ok "); };

i=67535-1000;

if (i>=65535) { printf("\n False "); } else { printf("\n Ok "); };

i=67535/1;

if (i>=65535) { printf("\n False "); } else { printf("\n Ok "); };

}

Файл: 6.хх/15.cpp

Тест 6.15 // правильный тест

#include

#include

#include

void main_6_15(void)

{signed char i;

signed short q;

signed short int w;

signed int e;

signed long int r;

signed long long int t;

i=-127; q=i; w=i; e=i; r=i; t=i;

printf("\n Ok");

q=-32767; w=q; e=q; r=q; t=q;

printf("\n Ok ");

r=-2147483647; t=r;

printf("\n Ok ");

}

Файл: 6.хх/16.cpp

Тест 6.16 // правильный тест,

#include

#include

#include

void main_6_16(void)

{ unsigned char i;

unsigned short q;

unsigned short int w;

unsigned int e;

unsigned long int r;

unsigned long long int t;

i=255; q=i; w=i; e=i; r=i; t=i;

printf("\n Ok ");

q=65535; w=q; e=q; r=q; t=q;

printf("\n Ok ");

r=4294967295; t=r;

printf("\n Ok ");

}

Файл: 6.хх/17.cpp

Тест 6.17// правильный тест,

#include

#include

void main_6_17(void)

{ char i; signed char q;

i=-127;

q=-127;

printf("\n Ok ");

}

Файл: 6.хх/18.cpp

Тест 6.18 //не правильный тест

#include

#include

#include

void main_6_18(void)

{ int b[5];

b[1]=1;

b[2]=2;

b[3]=3;

printf("\n b[1]=%d ", b[1]);

printf("\n b[2]=%d ", b[2]);

printf("\n b[3]= %d ", b[3]);

printf("\n b[4]= %d ", b[4]);

printf("\n False ");

}

Файл: 6.хх/19.cpp

Тест 6.19 // правильный тест

#include

#include

#include

void main_6_19(void)

{ int b[3];

b[1]=1;

b[2]=2;

b[3]=3;

printf("\n b[1]=%d ", b[1]);

printf("\n b[2]=%d ", b[2]);

printf("\n b[3]= %d ", b[3]);

printf("\n Ok ");

}

Файл: 6.хх/20.cpp

Тест 6.20 // правильный тест

#include

#include

#include

void main_6_20(void)

{ float i, q; int t;

t=*i; q=*i;

printf("\n t= %d ",t);

printf("\n q= %f ",q);

if (t==q) { printf("\n Ok "); } else { printf("\n False "); };

}

Представления типов

Файл: 7.хх/01.cpp

Тест 7.01 // правильный тест

#include

#include

#include

void main_7_01(void)

{ int b[3];

b[1]=1;

b[2]=2;

b[3]=3e1;

printf("\n b[1]=%d ", b[1]);

printf("\n b[2]=%d ", b[2]);

printf("\n b[3]= %d ", b[3]);

printf("\n Ok ");

}

Файл: 7.хх/02.cpp

Тест 7.02 // правильный тест

#include

#include

#include

void main_7_02(void)

{ signed long int b[3];

b[1]=1000;

b[2]=2000;

b[3]=3000;

printf("\n b[1]=%d ", b[1]);

printf("\n b[2]=%d ", b[2]);

printf("\n b[3]= %d ", b[3]);

printf("\n Ok ");

}

Файл: 7.хх/03.cpp

Тест 7.03 // правильный тест signed char

#include

#include

#include

void main_7_03(void)

{ signed char i, w, t;

w=-120; t=-1;

i=w*t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

w=-120; t=1;

i=w*t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

i=w+t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

i=w-t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

i=w/t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/04.cpp

Тест 7.04 // правильный тест unsigned char

#include

#include

#include

void main_7_04(void)

{ unsigned char i, w, t;

w=120; t=1;

i=w*t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

i=w/t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

i=w+t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

i=w-t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/05.cpp

Тест 7.05// правильный тест unsigned char

#include

#include

#include

void main_7_05(void)

{ unsigned char i, w, t; signed char z;

w=1; t=120;

i=w-t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

z=w-t;

if (z<0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/06.cpp

Тест 7.06 // правильный тест signed short

#include

#include

#include

void main_7_06(void)

{ signed short i, w, t;

w=-120; t=-1;

i=w*t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

w=-120; t=1;

i=w*t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

i=w+t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

i=w-t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

i=w/t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/07.cpp

Тест 7.07 // правильный тест unsigned short

#include

#include

#include

void main_7_07(void)

{ unsigned short i, w, t;

w=120; t=1;

i=w*t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

i=w/t;

if (i>0) { printf("\n Ok"); } else { printf("\n False "); };

i=w+t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

i=w-t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/08.cpp

Тест 7.08 // правильный тест unsigned short

#include

#include

#include

void main_7_08(void)

{ unsigned short i, w, t; signed short z;

w=1; t=120;

i=w-t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

z=w-t;

if (z<0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/09.cpp

Тест 7.09 // правильный тест signed short int

#include

#include

#include

void main_7_09(void)

{ signed short int i, w, t;

w=-120; t=-1;

i=w*t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

w=-120; t=1;

i=w*t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

i=w+t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

i=w-t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

i=w/t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/10.cpp

Тест 7.10// правильный тест unsigned short int

#include

#include

#include

void main_7_10(void)

{ unsigned short int i, w, t;

w=120; t=1;

i=w*t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

i=w/t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

i=w+t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

i=w-t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/11.cpp

Тест 7.11 // правильный тест unsigned short int

#include

#include

#include

void main_7_11(void)

{ unsigned short int i, w, t; signed short int z;

w=1; t=120;

i=w-t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

z=w-t;

if (z<0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/12.cpp

Тест 7.12 // правильный тест signed int

#include

#include

#include

void main_7_12(void)

{ signed int i, w, t;

w=-120; t=-1;

i=w*t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

w=-120; t=1;

i=w*t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

i=w+t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

i=w-t;

if (i<0) { printf("\n Ok"); } else { printf("\n False "); };

i=w/t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/13.cpp

Тест 7.13 // правильный тест unsigned int

#include

#include

#include

void main_7_13(void)

{ unsigned int i, w, t;

w=120; t=1;

i=w*t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

i=w/t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

i=w+t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

i=w-t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/14.cpp

Тест 7.14 // правильный тест unsigned int

#include

#include

#include

void main_7_14(void)

{ unsigned int i, w, t; signed int z;

w=1; t=120;

i=w-t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

z=w-t;

if (z<0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/15.cpp

Тест 7.15 // правильный тест signed long int

#include

#include

#include

void main_7_15(void)

{ signed long int i, w, t;

w=-120; t=-1;

i=w*t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

w=-120; t=1;

i=w*t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

i=w+t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

i=w-t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

i=w/t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/16.cpp

Тест 7.16 // правильный тест unsigned long int

#include

#include

#include

void main_7_16(void)

{ unsigned int i, w, t;

w=120; t=1;

i=w*t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

i=w/t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

i=w+t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

i=w-t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/17.cpp

Тест 7.17 // правильный тест unsigned long int

#include

#include

#include

void main_7_17(void)

{ unsigned long int i, w, t; signed long int z;

w=1; t=120;

i=w-t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

z=w-t;

if (z<0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/18.cpp

Тест 7.18 // правильный тест signed long long int

#include

#include

#include

void main_7_18(void)

{ signed long long int i, w, t;

w=-120; t=-1;

i=w*t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

w=-120; t=1;

i=w*t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

i=w+t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

i=w-t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

i=w/t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/19.cpp

Тест 7.19 // правильный тест unsigned long long int

#include

#include

#include

void main_7_19(void)

{ unsigned long long int i, w, t;

w=120; t=1;

i=w*t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

i=w/t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

i=w+t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

i=w-t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/20.cpp

Тест 7.20 // правильный тест unsigned long long int

#include

#include

#include

void main_7_20(void)

{ unsigned long long int i, w, t; signed long long int z;

w=1; t=120;

i=w-t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

z=w-t;

if (z<0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/21.cpp

Тест 7.21 // правильный тест float

#include

#include

#include

void main_7_21(void)

{ float w, t;

w=-120e10; t=-1e10;

i=w*t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

w=-120e10; t=1e10;

i=w*t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

i=w+t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

i=w-t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

i=w/t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/22.cpp

Тест 7.22 // правильный тест float

#include

#include

#include

void main_7_22(void)

{float i, w, t;

w=120e10; t=1e10;

i=w*t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

i=w/t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

i=w+t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

i=w-t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

i=t-w;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/23.cpp

Тест 7.23 // правильный тест double float

#include

#include

#include

void main_7_23(void)

{ double float w, t;

w=-120e100; t=-1e100;

i=w*t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

w=-120e100; t=1e100;

i=w*t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

i=w+t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

i=w-t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

i=w/t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/24.cpp

Тест 7.24 // правильный тест double float

#include

#include

#include

void main_7_24(void)

{ double float i, w, t;

w=120e100; t=1e100;

i=w*t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

i=w/t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

i=w+t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

i=w-t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

i=t-w;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/25.cpp

Тест 7.25 // правильный тест long double float

#include

#include

#include

void main_7_25(void)

{ long double float w, t;

w=-120e1000; t=-1e1000;

i=w*t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

w=-120e1000; t=1e1000;

i=w*t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

i=w+t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

i=w-t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

i=w/t;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/26.cpp

Тест 7.26 // правильный тест long double float

#include

#include

#include

void main_7_26(void)

{ long double float i, w, t;

w=120e1000; t=1e1000;

i=w*t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

i=w/t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

i=w+t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

i=w-t;

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

i=t-w;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/27.cpp

Тест 7.27 // не правильный тест

#include

#include

#include

void main_7_27(void)

{ signed char i; unsigned char q;

i=255; printf("\n i= %d ",i);

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

q=-127; printf("\n q= %d ",q);

if (q<0) { printf("\n Ok "); } else { printf("\n False "); };

printf("\n False ");

}

Файл: 7.хх/28.cpp

Тест 7.28 // не правильный тест

#include

#include

#include

void main_7_28(void)

{ signed short i; unsigned short q;

i=65535; printf("\n i= %d ",i);

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

q=-32767; printf("\n q= %d ",q);

if (q<0) { printf("\n Ok "); } else { printf("\n False "); };

printf("\n False ");

}

Файл: 7.хх/29.cpp

Тест 7.29 // не правильный тест

#include

#include

#include

void main_7_29(void)

{ signed short int i; unsigned short int q;

i=65535; printf("\n i= %d ",i);

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

q=-32767; printf("\n q= %d ",q);

if (q<0) { printf("\n Ok "); } else { printf("\n False "); };

printf("\n False ");

}

Файл: 7.хх/30.cpp

Тест 7.30 // не правильный тест

#include

#include

#include

void main_7_30(void)

{ signed int i; unsigned int q;

i=65535; printf("\n i= %d ",i);

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

q=-32767; printf("\n q= %d ",q);

if (q<0) { printf("\n Ok "); } else { printf("\n False "); };

printf("\n False ");

}

Файл: 7.хх/31.cpp

Тест 7.31 // не правильный тест

#include

#include

#include

void main_7_31(void)

{ signed long int i; unsigned long int q;

i=4294967295; printf("\n i= %d ",i);

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

q=-2147483647; printf("\n q= %d ",q);

if (q<0) { printf("\n Ok "); } else { printf("\n False "); };

printf("\n False ");

}

Файл: 7.хх/32.cpp

Тест 7.32 // не правильный тест

#include

#include

#include

void main_7_32(void)

{ signed long long int i; unsigned long long int q;

i=18446744073709551615; printf("\n i= %d ",i);

if (i>0) { printf("\n Ok "); } else { printf("\n False "); };

q=-9223372036854775807; printf("\n q= %d ",q);

if (q<0) { printf("\n Ok "); } else { printf("\n False "); };

printf("\n False ");

}

Файл: 7.хх/33.cpp

Тест 7.33 // правильный тест signed char

#include

#include

#include

void main_7_33(void)

{ signed char i;

i=-0;

if (i==0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/34.cpp

Тест 7.34 // правильный тест signed short

#include

#include

#include

void main_7_34(void)

{ signed short i;

i=-0;

if (i==0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/35.cpp

Тест 7.35 // правильный тест signed short int

#include

#include

#include

void main_7_35(void)

{ signed short int i;

i=-0;

if (i==0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/36.cpp

Тест 7.36 // правильный тест signed int

#include

#include

#include

void main_7_36(void)

{ signed int i;

i=-0;

if (i==0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/37.cpp

Тест 7.37 // правильный тест signed long int

#include

#include

#include

void main_7_37(void)

{ signed long int i;

i=-0;

if (i==0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/38.cpp

Тест 7.38 // правильный тест signed long long int

#include

#include

#include

void main_7_38(void)

{ signed long long int i;

i=-0;

if (i==0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/39.cpp

Тест 7.39 // правильный тест signed char

#include

#include

#include

void main_7_39(void)

{ signed char i;

i=127+1;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

i=129-1;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/40.cpp

Тест 7.40 // правильный тест signed short

#include

#include

#include

void main_7_40(void)

{ signed short i;

i=32767+1;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

i=32769-1;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/41.cpp

Тест 7.41 // правильный тест signed short int

#include

#include

#include

void main_7_41(void)

{ signed short int i;

i=32767+1;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

i=32769-1;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/42.cpp

Тест 7.42 // правильный тест signed long int

#include

#include

#include

void main_7_42(void)

{ signed long int i;

i=2147483647+1;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

i=2147483649-1;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/43.cpp

Тест 7.43 // правильный тест signed long int

#include

#include

#include

void main_7_43(void)

{ signed long int i;

i=9223372036854775807+1;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

i=9223372036854775809-1;

if (i<0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/44.cpp

Тест 7.44 // правильный тест signed char

#include

#include

#include

void main_7_44(void)

{ signed char i;

i=1-0;

if (i==1) { printf("\n Ok "); } else { printf("\n False "); };

i=-0+1;

if (i==1) { printf("\n Ok "); } else { printf("\n False "); };

i=-0*1;

if (i==0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/45.cpp

Тест 7.45 // правильный тест signed long long int

#include

#include

#include

void main_7_45(void)

{ signed long long int i;

i=1-0;

if (i==1) { printf("\n Ok "); } else { printf("\n False "); };

i=-0+1;

if (i==1) { printf("\n Ok "); } else { printf("\n False "); };

i=-0*1;

if (i==0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/46.cpp

Тест 7.46 // правильный тест signed char

#include

#include

#include

void main_7_46(void)

{ signed char i;

i=1-0;

if (i==1) { printf("\n Ok "); } else { printf("\n False "); };

i=-0+1;

if (i==1) { printf("\n Ok "); } else { printf("\n False "); };

i=-0*1;

if (i==0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/47.cpp

Тест 7.47 // правильный тест signed long long int

#include

#include

#include

void main_7_47(void)

{ signed long long int i;

i=1-0;

if (i==1) { printf("\n Ok "); } else { printf("\n False "); };

i=-0+1;

if (i==1) { printf("\n Ok "); } else { printf("\n False "); };

i=-0*1;

if (i==0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/48.cpp

Тест 7.48 // правильный тест signed int

#include

#include

#include

void main_7_48(void)

{ signed int i; unsigned int q;

i=0;

q=0;

if (i==q) { printf("\n Ok "); } else { printf("\n False "); };

i=100;

q=100;

if (i==q) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/49.cpp

Тест 7.49 // правильный тест signed int

#include

#include

#include

void main_7_49(void)

{ signed int i; unsigned int q, w;

i=1;

q=50;

w=i+q;

if (w==51) { printf("\n Ok "); } else { printf("\n False "); };

w=i*q;

if (w==50) { printf("\n Ok "); } else { printf("\n False "); };

w=q/i;

if (w==50) { printf("\n Ok "); } else { printf("\n False "); };

w=q-i;

if (w==49) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 7.хх/50.cpp

Тест 7.50 // правильный тест signed long long int

#include

#include

#include

void main_7_50(void)

{ signed long long int i; unsigned long long int q, w;

i=1;

q=50;

w=i+q;

if (w==51) { printf("\n Ok "); } else { printf("\n False "); };

w=i*q;

if (w==50) { printf("\n Ok "); } else { printf("\n False "); };

w=q/i;

if (w==50) { printf("\n Ok "); } else { printf("\n False "); };

w=q-i;

if (w==49) { printf("\n Ok "); } else { printf("\n False "); };

}

Преобразования

Файл: 8.хх/01.cpp

Тест 8.01 // правильный тест преобразование signed int, unsigned int

#include

#include

#include

void main_8_01(void)

{ signed int i; unsigned int q;

i=7;

q=i;

if (i==q) { printf("\n Ok "); } else { printf("\n False "); };

if (q==7) { printf("\n Ok "); } else { printf("\n False "); };

q=10;

i=q;

if (i==q) { printf("\n Ok "); } else { printf("\n False "); };

if (i==10) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 8.хх/02.cpp

Тест 8.02 // не правильный тест преобразование signed int, unsigned int

#include

#include

#include

void main_8_02(void)

{ signed int i; unsigned int q;

i=-7;

q=i;

if (i==q) { printf("\n False "); } else { printf("\n Ok "); };

q=-10;

i=q;

if (i==q) { printf("\n False "); } else { printf("\n Ok "); };

}

Файл: 8.хх/03.cpp

Тест 8.03 // правильный тест преобразование signed char, unsigned char

#include

#include

#include

void main_8_03(void)

{ signed char i; unsigned char q;

i=7;

q=i;

if (i==q) { printf("\n Ok "); } else { printf("\n False "); };

if (q==7) { printf("\n Ok "); } else { printf("\n False "); };

q=10;

i=q;

if (i==q) { printf("\n Ok "); } else { printf("\n False "); };

if (i==10) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 8.хх/04.cpp

Тест 8.04 // не правильный тест преобразование signed char, unsigned char

#include

#include

#include

void main_8_04(void)

{ signed char i; unsigned char q;

i=-7;

q=i;

if (i==q) { printf("\n False "); } else { printf("\n Ok "); };

q=-10;

i=q;

if (i==q) { printf("\n False "); } else { printf("\n Ok "); };

}

Файл: 8.хх/05.cpp

Тест 8.05 // правильный тест преобразование signed long int, unsigned long int

#include

#include

#include

void main_8_05(void)

{ signed long int i; unsigned long int q;

i=7;

q=i;

if (i==q) { printf("\n Ok "); } else { printf("\n False "); };

if (q==7) { printf("\n Ok "); } else { printf("\n False "); };

q=10;

i=q;

if (i==q) { printf("\n Ok "); } else { printf("\n False "); };

if (i==10) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 8.хх/06.cpp

Тест 8.06 // правильный тест преобразование signed long long int, unsigned long long int

#include

#include

#include

void main_8_06(void)

{ signed long long int i; unsigned long long int q;

i=7;

q=i;

if (i==q) { printf("\n Ok "); } else { printf("\n False "); };

if (q==7) { printf("\n Ok "); } else { printf("\n False "); };

q=10;

i=q;

if (i==q) { printf("\n Ok "); } else { printf("\n False "); };

if (i==10) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 8.хх/07.cpp

Тест 8.07 // правильный тест

#include

#include

#include

void main_8_07(void)

{ signed int i; unsigned long long int q; float f; signed char ch; _Bool bol;

i=-7;

q=10;

f=0.1e20;

ch= "char";

bol=i;

if (bol==0) { printf("\n Ok "); } else { printf("\n False "); };

bol=q;

if (bol==0) { printf("\n Ok "); } else { printf("\n False "); };

bol=f;

if (bol==0) { printf("\n Ok "); } else { printf("\n False "); };

bol=ch;

if (bol==0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 8.хх/08.cpp

Тест 8.08 // правильный тест

#include

#include

#include

void main_8_08(void)

{ signed int i; unsigned int q;

i=7;

q=i;

if (i==q) { printf("\n Ok "); } else { printf("\n False "); };

q=7;

i=q;

if (q==i) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 8.хх/09.cpp

Тест 8.09 // правильный тест

#include

#include

#include

void main_8_09(void)

{ signed int i; unsigned int q;

i=-7;

q=i;

if (q==i) { printf("\n False "); } else { printf("\n Ok "); };

if (q==0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 8.хх/10.cpp

Тест 8.10 // правильный тест unsigned int

#include

#include

#include

void main_8_10(void)

{ signed long long int i; unsigned int q;

i=9223372036854775807;

q=i;

if (q==65535) { printf("\n Ok "); } else { printf("\n False "); };

i=-9223372036854775807;

q=i;

if (q==0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 8.хх/11.cpp

Тест 8.11 // правильный тест

#include

#include

#include

void main_8_11(void)

{ signed long long int i; unsigned long int q;

i=9223372036854775807;

q=i;

if (q==4294967295) { printf("\n Ok "); } else { printf("\n False "); };

i=-9223372036854775807;

q=i;

if (q==0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 8.хх/12.cpp

Тест 8.12 // правильный тест

#include

#include

#include

void main_8_12(void)

{ signed long long int i; unsigned long long int q;

i=9223372036854775807;

q=i;

if (q==9223372036854775807) { printf("\n Ok "); } else { printf("\n False "); };

i=-9223372036854775807;

q=i;

if (q==0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 8.хх/13.cpp

Тест 8.13 // правильный тест

#include

#include

#include

void main_8_13(void)

{ signed int i; signed long long int lon; float f;

f=0.777e2;

if (f==0.777e2) { printf("\n Ok "); } else { printf("\n False "); };

i=f;

if (i==77) { printf("\n Ok "); } else { printf("\n False "); }

printf("\n i=%d",i);

lon=0.3333e7;

if (lon==3333000) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 8.хх/14.cpp

Тест 8.14 // правильный тест signed int

#include

#include

#include

void main_8_14(void)

{ signed int i; float f;

f=0;

i=f;

if (i==0) { printf("\n Ok "); } else { printf("\n False "); };

f=0.32767e5;

i=f;

if (i==32767) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 8.хх/15.cpp

Тест 8.15 // правильный тест unsigned int

#include

#include

#include

void main_8_15(void)

{ unsigned int i; float f;

f=0;

i=f;

if (i==0) { printf("\n Ok "); } else { printf("\n False "); };

f=0. 65535e5;

i=f;

if (i==65535) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 8.хх/16.cpp

Тест 8.16// правильный тест signed short

#include

#include

#include

void main_8_16(void)

{ signed short i; float f;

f=0;

i=f;

if (i==0) { printf("\n Ok "); } else { printf("\n False "); };

f=0.32767e5;

i=f;

if (i==32767) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 8.хх/17.cpp

Тест 8.17// правильный тест unsigned short

#include

#include

#include

void main_8_17(void)

{ unsigned short i; float f;

f=0;

i=f;

if (i==0) { printf("\n Ok "); } else { printf("\n False "); };

f=0. 65535e5;

i=f;

if (i==65535) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 8.хх/18.cpp

Тест 8.18 // правильный тест signed long int

#include

#include

#include

void main_8_18(void)

{ signed long int i; double float f;

f=0;

i=f;

if (i==0) { printf("\n Ok "); } else { printf("\n False "); }

f=0. 2147483647e10;

i=f;

if (i==2147483647) { printf("\n Ok "); } else { printf("\n False "); }

}

Файл: 8.хх/19.cpp

Тест 8.19 // правильный тест unsigned long int

#include

#include

#include

void main_8_19(void)

{ unsigned long int i; double float f;

f=0;

i=f;

if (i==0) { printf("\n Ok "); } else { printf("\n False "); };

f=0. 4294967295e10;

i=f;

if (i==4294967295) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 8.хх/20.cpp

Тест 8.20 // правильный тест signed long long int // все таки проверить кол-во цифр в основании

#include

#include

#include

void main(void)

{ signed long long int i; double float f;

f=0;

i=f;

if (i==0) { printf("\n Ok "); } else { printf("\n False "); };

f=0.9223372036854775807e19;

i=f;

if (i==9223372036854775807) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 8.хх/21.cpp

Тест 8.21 // правильный тест unsigned long long int

#include

#include

#include

void main_8_21(void)

{ unsigned long long int i; double float f;

f=0;

i=f;

if (i==0) { printf("\n Ok "); } else { printf("\n False "); };

f=0.18446744073709551615e20;

i=f;

if (i==18446744073709551615) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 8.хх/22.cpp

Тест 8.22 // правильный тест, преобразование float к double и long double

#include

#include

#include

void main_8_22(void)

{ float f; double float df; long double float ldf;

f=-1e10;

df=f;

ldf=f;

if (df==-1e10) { printf("\n Ok "); } else { printf("\n False "); };

if (ldf==-1e10) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 8.хх/23.cpp

Тест 8.23 // правильный тест, преобразование double к long double

#include

#include

#include

void main_8_23(void)

{ double float df; long double float ldf;

df=-1e10;

ldf=df;

if (ldf==-1e10) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 8.хх/24.cpp

Тест 8.24 // правильный тест, double понижен к float, значение точно может быть представлено

#include

#include

#include

void main_8_24(void)

{ float f; double float df;

df=-1e10;

f=df;

if (f==-1e10) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 8.хх/25.cpp

Тест 8.25 // правильный тест, double понижен к float, значение обладает большей точностью

#include

#include

#include

void main_8_25(void)

{ float f; double float df;

df=-1e200;

f=df;

if (f<-1e200) { printf("\n Ok"); } else { printf("\n False "); };

if (f<-1e39) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 8.хх/26.cpp

Тест 8.26 // правильный тест, long double понижен к double, значение точно может быть представлено

##include

#include

#include

void main_8_26(void)

{ double float df; long double float ldf;

ldf=-1e300;

df=ldf;

if (df==-1e300) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 8.хх/27.cpp

Тест 8.27 // правильный тест, long double понижен к double, значение обладает большей точностью

#include

#include

#include

void main_8_27(void)

{ double float df; long double float ldf;

ldf=-1e4000;

df=ldf;

if (df<-1e4000) { printf("\n Ok "); } else { printf("\n False "); };

if (df<-1e309) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 8.хх/28.cpp

Тест 8.28 // правильный тест, long double понижен к float, значение точно может быть представлено

#include

#include

#include

void main_8_28(void)

{ float f; long double float ldf;

ldf=-1e10;

f=ldf;

if (f==-1e10) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 8.хх/29.cpp

Тест 8.29 // правильный тест, long double понижен к float, значение обладает большей точностью

#include

#include

#include

void main_8_29(void)

{ float f; long double float ldf;

ldf=-1e4000;

f=ldf;

if (f<-1e309) { printf("\n Ok "); } else { printf("\n False "); };

if (f<-1e39) { printf("\n Ok "); } else { printf("\n False "); };

}

Обычные арифметические преобразования

Файл: 9.хх/01.cpp

Тест 9.01 // правильный тест, float

#include

#include

#include

void main_9_01(void)

{ float f,r; long double float ldf;

ldf=-1e4000;

f=-1e10;

r=ldf+f;

if (sizeof(r)==10) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(f)==10) { printf("\n Ok "); } else { printf("\n False "); };

r=ldf-f;

if (sizeof(r) ==10) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(f)==10) { printf("\n Ok "); } else { printf("\n False "); };

r=ldf*f;

if (sizeof(r)==10) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(f)==10) { printf("\n Ok"); } else { printf("\n False "); };

r=ldf/f;

if (sizeof(r)==10) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(f)==10) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 9.хх/02.cpp

Тест 9.02 // правильный тест, double float

#include

#include

#include

void main_9_02(void)

{ double float df,r; long double float ldf;

ldf=-1e4000;

df=-1e100;

r=ldf+df;

if (sizeof(r)==10) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(df)==10) { printf("\n Ok "); } else { printf("\n False "); };

r=ldf-df;

if (sizeof(r)==10) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(df)==10) { printf("\n Ok "); } else { printf("\n False "); };

r=ldf*df;

if (sizeof(r)==10) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(df)==10) { printf("\n Ok"); } else { printf("\n False "); };

r=ldf/df;

if (sizeof(r)==10) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(df)==10) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 9.хх/03.cpp

Тест 9.03 // правильный тест, signed int

#include

#include

#include

void main_9_03(void)

{ signed int i,r; long double float ldf;

ldf=-1e4000;

i=-1;

r=ldf+i;

if (sizeof(r)==10) { printf("\n Ok"); } else { printf("\n False "); };

if (sizeof(i)==10) { printf("\n Ok "); } else { printf("\n False "); };

r=ldf-i;

if (sizeof(r)==10) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(i)==10) { printf("\n Ok "); } else { printf("\n False "); };

r=ldf*i;

if (sizeof(r)==10) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(i)==10) { printf("\n Ok "); } else { printf("\n False "); };

r=ldf/i;

if (sizeof(r)==10) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(i)==10) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 9.хх/04.cpp

Тест 9.04// правильный тест, float

#include

#include

#include

void main_9_04(void)

{ float f,r,ff;

ff=-7e10;

f=-1e10;

r=ff+f;

if (sizeof(r)== sizeof(f)) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(r)== sizeof(ff)) { printf("\n Ok"); } else { printf("\n False "); };

r=ff-f;

if (sizeof(r)== sizeof(f)) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(r)== sizeof(ff)) { printf("\n Ok "); } else { printf("\n False "); };

r=ff*f;

if (sizeof(r)== sizeof(f)) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(r)== sizeof(ff)) { printf("\n Ok"); } else { printf("\n False "); };

r=ff/f;

if (sizeof(r)== sizeof(f)) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(r)== sizeof(ff)) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 9.хх/05.cpp

Тест 9.05// правильный тест, signed int

#include

#include

#include

void main_9_05(void)

{ signed int f,r,ff;

ff=-700;

f=-1;

r=ff+f;

if (sizeof(r)== sizeof(f)) { printf("\n Ok"); } else { printf("\n False "); };

if (sizeof(r)== sizeof(ff)) { printf("\n Ok"); } else { printf("\n False "); };

r=ff-f;

if (sizeof(r)== sizeof(f)) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(r)== sizeof(ff)) { printf("\n Ok "); } else { printf("\n False "); };

r=ff*f;

if (sizeof(r)== sizeof(f)) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(r)== sizeof(ff)) { printf("\n Ok "); } else { printf("\n False "); };

r=ff/f;

if (sizeof(r)== sizeof(f)) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(r)== sizeof(ff)) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 9.хх/06.cpp

Тест 9.06 // правильный тест, signed long int

#include

#include

#include

void main_9_06(void)

{ signed int i,r; signed long int li;

li=-700;

i=-1;

r=li+i;

if (sizeof(li)>= sizeof(i)) { printf("\n Ok"); } else { printf("\n False "); };

if (sizeof(r)== sizeof(li)) { printf("\n Ok"); } else { printf("\n False "); };

r=li-i;

if (sizeof(li)>= sizeof(i)) { printf("\n Ok"); } else { printf("\n False "); };

if (sizeof(r)== sizeof(li)) { printf("\n Ok "); } else { printf("\n False "); };

r=li*i;

if (sizeof(li)>= sizeof(i)) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(r)== sizeof(li)) { printf("\n Ok "); } else { printf("\n False "); };

r=li/i;

if (sizeof(li)>= sizeof(i)) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(r)== sizeof(li)) { printf("\n Ok"); } else { printf("\n False "); };

}

Файл: 9.хх/07.cpp

Тест 9.07 // правильный тест, signed long long int

#include

#include

#include

void main_9_07(void)

{ signed int i,r; signed long long int li;

li=-7000;

i=-1;

r=li+i;

if (sizeof(li)>= sizeof(i)) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(r)== sizeof(li)) { printf("\n Ok "); } else { printf("\n False "); };

r=li-i;

if (sizeof(li)>= sizeof(i)) { printf("\n Ok"); } else { printf("\n False "); };

if (sizeof(r)== sizeof(li)) { printf("\n Ok "); } else { printf("\n False "); };

r=li*i;

if (sizeof(li)>= sizeof(i)) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(r)== sizeof(li)) { printf("\n Ok "); } else { printf("\n False "); };

r=li/i;

if (sizeof(li)>= sizeof(i)) { printf("\n Ok"); } else { printf("\n False "); };

if (sizeof(r)== sizeof(li)) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 9.хх/08.cpp

Тест 9.08 // правильный тест, signed long int

#include

#include

#include

void main_9_08(void)

{ signed long int i,r; signed long double int li;

li=-70000;

i=-1;

r=li+i;

if (sizeof(li)>= sizeof(i)) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(r)== sizeof(li)) { printf("\n Ok"); } else { printf("\n False "); };

r=li-i;

if (sizeof(li)>= sizeof(i)) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(r)== sizeof(li)) { printf("\n Ok "); } else { printf("\n False "); };

r=li*i;

if (sizeof(li)>= sizeof(i)) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(r)== sizeof(li)) { printf("\n Ok "); } else { printf("\n False "); };

r=li/i;

if (sizeof(li)>= sizeof(i)) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(r)== sizeof(li)) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 9.хх/09.cpp

Тест 9.09 // правильный тест, signed int

#include

#include

#include

void main_9_09(void)

{ signed int i,r; unsigned long long int li;

li=70000;

i=10;

r=li+i;

if (sizeof(li)>= sizeof(i) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(r)== sizeof(li)) { printf("\n Ok "); } else { printf("\n False "); };

r=li-i;

if (sizeof(li)>= sizeof(i)) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(r)== sizeof(li)) { printf("\n Ok "); } else { printf("\n False "); };

r=li*i;

if (sizeof(li)>= sizeof(i)) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(r)== sizeof(li)) { printf("\n Ok "); } else { printf("\n False "); };

r=li/i;

if (sizeof(li)>= sizeof(i)) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(r)== sizeof(li)) { printf("\n Ok"); } else { printf("\n False "); };

}

Файл: 9.хх/10.cpp

Тест 9.10 // правильный тест, signed int

#include

#include

#include

void main(void)

{ signed int i,r; unsigned long int li;

li=70000;

i=10;

r=li+i;

if (sizeof(li)>= sizeof(i)) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(r)== sizeof(li)) { printf("\n Ok "); } else { printf("\n False "); };

r=li-i;

if (sizeof(li)>= sizeof(i)) { printf("\n Ok"); } else { printf("\n False "); };

if (sizeof(r)== sizeof(li)) { printf("\n Ok "); } else { printf("\n False "); };

r=li*i;

if (sizeof(li)>= sizeof(i)) { printf("\n Ok "); } else { printf("\n False "); };

if (sizeof(r)== sizeof(li)) { printf("\n Ok "); } else { printf("\n False "); };

r=li/i;

if (sizeof(li)>= sizeof(i)) { printf("\n Ok"); } else { printf("\n False "); };

if (sizeof(r)== sizeof(li)) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 9.хх/11.cpp

Тест 9.11 // правильный тест, signed int

#include

#include

#include

void main_9_11(void)

{ signed int i,r; unsigned int li;

li=7;

i=-100;

r=li+i;

if (sizeof(li)== sizeof(i)) { printf("\n Ok"); } else { printf("\n False "); };

if (r<0) { printf("\n Ok "); } else { printf("\n False "); };

r=i-li;

if (sizeof(li)== sizeof(i)) { printf("\n Ok "); } else { printf("\n False "); };

if (r<0) { printf("\n Ok "); } else { printf("%n False "); };

r=li*i;

if (sizeof(li)== sizeof(i)) { printf("%n Ok "); } else { printf("\n False "); };

if (r<0) { printf("\n Ok "); } else { printf("%n False "); };

r=i/li;

if (sizeof(li)== sizeof(i)) { printf("\n Ok "); } else { printf("\n False "); };

if (r<0) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 9.хх/12.cpp

Тест 9.12 // правильный тест

#include

#include

#include

void main_9_12(void)

{ float f;

f=-1e4000+7e4000;

if (sizeof(f)= 10) { printf("\n Ok "); } else { printf("\n False "); };

f=-1e4000-7e4000;

if (sizeof(f)= 10) { printf("\n Ok"); } else { printf("\n False "); };

f=-1e10*7e400;

if (sizeof(f)= 10) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 9.хх/13.cpp

Тест 9.13 // правильный тест

#include

#include

#include

void main_9_13(void)

{ double float f;

f=-1e4000+7e4000;

if (sizeof(f)= 10) { printf("\n Ok "); } else { printf("\n False "); };

f=-1e4000-7e4000;

if (sizeof(f)= 10) { printf("\n Ok"); } else { printf("\n False "); };

f=-1e10*7e400;

if (sizeof(f)= 10) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 10.хх/01.cpp

Тест 10.01 // правильный тест, signed long int

#include

void main_10_01(void)

{ char *p = 0;

printf("\n Ок ");

}

Файл: 10.хх/02.cpp

Тест 10.02 // правильный тест, signed long int

#define NULL ((void *)0)

void main_10_02(void)

{ char *fp = NULL;

printf("\n Ok ");

}

Файл: 10.хх/03.cpp

Тест 10.03 // правильный тест, signed long int

#include

#include

void main_10_03(void)

{ signed int *p = 0;

if (p == 0) { printf("\n Ok "); } else { printf("\n False "); };

if (p != 0) { printf("\n False "); } else { printf("\n Ok "); };

}

Файл: 10.хх/04.cpp

Тест 10.04 // правильный тест, signed long int

#include

#include

#include

void main_10_04(void)

{ signed int *p = 0, *z = 0; char *w =0;

if (*p == *z) { printf("\n Ok "); } else { printf("\n False "); };

if (p == z) { printf("\n Ok "); } else { printf("\n False "); };

f (*p == *w) { printf("\n Ok "); } else { printf("\n False "); };

if (p == w) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 10.хх/05.cpp

Тест 10.05 // правильный тест

#include

#include

#include

void main_10_05(void)

{ signed int x, y, z;

x=2; y=2;

z=x++ + ++y; // z=3+2=5

if (z == 5) { printf("\n Ok "); } else { printf("\n False "); };

z=(x++) + (++y); // z=3+2=5

if (z == 5) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 10.хх/06.cpp

Тест 10.06 // не правильный тест

#include

#include

#include

void main_10_06(void)

{ signed int x, y, z;

x=1; y=2;

z=x++ ++ +y;

printf("\n False ");

}

Файл: 10.хх/07.cpp

Тест 10.07 // не правильный тест

#include

#include

#include

void main_10_07(void)

{ signed int auto, break;

auto=1; break=1;

printf("\n False ");

}

Файл: 10.хх/08.cpp

Тест 10.08// не правильный тест

#include

#include

#include

void main_10_08(void)

{ signed int auto=1, break=1, case=1, char=1, const=1, continue=1, default=1, do=1, double=1, else=1, enum=1, extern=1, float=1, for=1, goto=1, if=1, inline=1, int=1, long=1, register=1, restrict=1, return=1, short=1, signed=1, sizeof=1, static=1, struct=1, switch=1, typedef=1, union=1, unsigned=1, void=1, volatile=1, while=1, _Bool=1, _Complex=1, _Imaginary=1;

printf("\n False ");

}

Файл: 10.хх/09.cpp

Тест 10.09 // правильный тест, различия нижнего и верхнего регистра

#include

#include

#include

void main_10_09(void)

{ signed int i; unsigned int I;

i=32767; printf("\n i= %d ",i);

I=65535; printf("\n I= %d ",I);

printf("\n i= %d ",i);

if (i ==I) { printf("\n False "); } else { printf("\n Ok "); };

}

Файл: 10.хх/10.cpp

Тест 10.10// правильный тест

#include

#include

#include

void main_10_10(void)

{ signed int _i, hHrtr8o; unsigned int Iqwertyuiopasdfghjklzxcvbnm; unsigned long int Iqwertyuiopasdfghjklzxcvbnmqwertyuiopasdfghjklzxcvbnmqwertyuiopasdfghjklzxcvbnmqwertyuiopasdfghjklzxcvbnm;

Iqwertyuiopasdfghjklzxcvbnm=12;

printf("\n Ok ");

}

Файл: 10.хх/11.cpp

Тест 10.11// не правильный тест

#include

#include

#include

void main_10_11(void)

{ signed int _888i, 1hHrtr8o; unsigned int Iqwertyuiopasdfghjklzxcvbnm; unsigned long int IqЦ6546er, 6345;

printf("\n False ");

}

Файл: 10.хх/12.cpp

Тест 10.12 // правильный тест

#include

void myfunc(void)

{printf("\n %s\n", _ _func_ _);

}

Файл: 11.хх/01.cpp

Тест 11.01 // правильный тест, шестнадцатерично - префиксный: один из 0x 0X

#include

#include

#include

void main_11_01(void)

{ signed int i, z;

i=0x9; printf("\n i= %d ",i);

if (i ==9) {printf("\n Ok "); } else { printf("\n False "); };

z=i+1; printf("\n i= %d ",i);

if (i ==10) { printf("\n False "); } else { printf("\n Ok "); };

if (i ==0xA) { printf("\n False "); } else { printf("\n Ok "); };

i=i+1;

if (i ==0xA) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 11.хх/02.cpp

Тест 11.02 // правильный тест, шестнадцатерично - префиксный: один из 0x 0X

#include

#include

#include

void main_11_02(void)

{ signed int i, z;

i=0X9; printf("\n i= %d ",i);

if (i ==9) { printf("\n Ok "); } else { printf("\n False "); };

z=i+1; printf("\n z= %d ",z);

if (i ==10) { printf("\n False "); } else { printf("\n Ok "); };

if (i ==0XA) { printf("\n False "); } else { printf("\n Ok "); };

i=i+1;

if (i ==0XA) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 11.хх/03.cpp

Тест 11.03// правильный тест, Отличная от нуля цифра: один из 1 2 3 4 5 6 7 8 9

void main_11_03(void)

{ if (0<1) { printf("\n Ok "); } else { printf("\n False "); };

if (0<2) { printf("\n Ok "); } else { printf("\n False "); };

if (0<3) { printf("\n Ok "); } else { printf("\n False "); };

if (0<4) { printf("\n Ok "); } else { printf("\n False "); };

if (0<5) { printf("\n Ok "); } else { printf("\n False "); };

if (0<6) { printf("\n Ok "); } else { printf("\n False "); };

if (0<7) { printf("n Ok "); } else { printf("\n False "); };

if (0<8) { printf("n Ok "); } else { printf("\n False "); };

if (0<9) { printf("n Ok "); } else { printf("\n False "); };

}

Файл: 11.хх/04.cpp

Тест 11.04// правильный тест, шестнадцатерично – префиксный

#include

#include

#include

void main_11_04(void)

{ signed int i, z;

i=0X9; printf("\n i= %d ",i);

i=0XA; printf("\n i= %d ",i);

i=0Xa; printf("\n i= %d ",i);

i=0X4F; printf("\n i= %d ",i);

i=0X4Fd; printf("\n i= %d ",i);

i=0x4Fd; printf("\n i= %d ",i);

printf("\n Ok ");

}

Файл: 11.хх/05.cpp

Тест 11.05 // не правильный тест

#include

#include

#include

void main_11_05(void)

{ signed int i, z;

i=.9; printf("\n i= %d ",i);

printf("\n False ");

}

Файл: 11.хх/06.cpp

Тест 11.06 // не правильный тест

#include

#include

#include

void main_11_06(void)

{ signed int i;

i=09; printf("\n i= %d ",i);

printf("\n False ");

}

Файл: 11.хх/07.cpp

Тест 11.07 // правильный тест

#include

#include

#include

void main_11_07(void)

{ signed int i;

i=01; printf("\n i= %d ",i);

i=07; printf("\n i= %d ",i);

printf("\n Ok ");

}

Файл: 11.хх/08.cpp

Тест 11.08 // не правильный тест

#include

#include

#include

void main_11_08(void)

{ signed int i;

i=0xT; printf("\n i= %d ",i);

printf("\n False ");

}

Файл: 11.хх/09.cpp

Тест 11.09// правильный тест

#include

#include

#include

void main_11_09(void)

{ signed int i;

i=0xF; printf("\n i= %d ",i);

i=0xA; printf("\n i= %d ",i);

printf("\n Ok ");

}

Файл: 11.хх/10.cpp

Тест 11.10// правильный тест

#include

#include

#include

void main_11_10(void)

{ signed int i;

i=0xF*2; printf("\n i= %d ",i);

if (i==0x1E) { printf("\n Ok "); } else { printf("\n False "); };

i=07*2; printf("\n i= %d ",i);

if (i==016) { printf("\n Ok "); } else { printf("\n False "); };

i=7*2; printf("\n i= %d ",i);

if (i==14) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 11.хх/11.cpp

Тест 11.11// правильный тест

#include

#include

#include

void main_11_11(void)

{ signed int i; char ch;

ch=" // b "; // четырех-символьный натягивают литерал

// */ // комментарий, не ошибка синтаксиса

//\

i=3; // часть комментария с двумя линиями

/* // */ i=7; // эквивалент i=7;

printf("\n Ok ");

}

Файл: 11.хх/12.cpp

Тест 11.12// правильный тест

#include

#include

void main_11_12(void)

{ signed int g, h, f;

g=10; h=5;

f = g/* *// h; // эквивалент f = g / h;

if (f==2) { printf("\n Ok "); } else { printf("\n False "); };

f = g //* */o

+ h; // эквивалент f= g+ h;

if (f==15) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 11.хх/13.cpp

Тест 11.13// не правильный тест

#include

#include

#define glue(x, y) x##y

void main_11_13(void)

{ signed int i;

glue (/, /) k (); // ошибка синтаксиса, не комментируют

printf("\n False ");

}

Файл: 11.хх/14.cpp

Тест 11.14// не правильный тест

#include

#include

#include

void main_11_14(void)

{ signed int i;

i=2;

i = ++ i + 1;

i=3;

a[ i ++] = i;

printf("\n False ");

}

Файл: 11.хх/15.cpp

Тест 11.15// не правильный тест

#include

#include

#include

void main_11_15(void)

{ signed int i;

i=2;

i = ++ i+ + 1;

i=3;

a[ i ++] = 1+i+;

printf("\n False ");

}

Файл: 11.хх/16.cpp

Тест 11.16 // правильный тест

#include

#include

#include

void main_11_16(void)

{ signed int i, a[2];

i=2;

i = i + 1;

if (i==3) { printf("\n Ok "); } else { printf("\n False "); };

a[i] = i;

printf("\n Ok ");

}

Файл: 11.хх/17.cpp

Тест 11.17// правильный тест

#include

#include

#include

void main_11_17(void)

{ signed int i, z;

i=2;

i += 5; /* ravnosil i=i+5 */

if (i==7) { printf("\n Ok "); } else { printf("\n False "); };

i=5;

z=(i++)*5; /* ravnosil z=i+5 i=i+1 */

if (z==25) { printf("\n Ok "); } else { printf("\n False "); };

if (i==6) { printf("\n Ok "); } else { printf("\n False "); };

}

Файл: 11.хх/18.cpp

Тест 11.18 // правильный тест

#include

#include

#include

void main_11_18(void)

{ signed int i, z;

i=9;

z=(++i)/5;

if (z==2) { printf("\n Ok "); } else { printf("\n False "); };

z=1; /* ekvivalent z++ = ++z */

z++;

i=1;

++i;

if (z==i) { printf("\n Ok "); } else { printf("\n False "); };

}

2. Библиотека limits.h

#ifndef __LIMITS_H

#define __LIMITS_H

#if !defined(___DEFS_H)

#include <_defs>

#endif

#define CHAR_BIT 8

#if ('\x80' < 0)

#define CHAR_MAX 127

#define CHAR_MIN (-128)

#else

#define CHAR_MAX 255

#define CHAR_MIN 0

#endif

#define SCHAR_MAX 127

#define SCHAR_MIN (-128)

#define UCHAR_MAX 255

#define SHRT_MAX 0x7FFF //+ 32767 // 2*15 - 1

#define SHRT_MIN ((int)0x8000) // 32767 // - (2*15 - 1)

#define USHRT_MAX 0xFFFFU //65535 // 2*16 - 1

#define INT_MAX 0x7FFF //+ 32767 // 2*15 - 1

#define INT_MIN ((int)0x8000) // 32767 // - (2*15 - 1)

#define UINT_MAX 0xFFFFU //65535 // 2*16 - 1

#define LONG_MAX 0x7FFFFFFFL // + 2147483647 // 2*31 - 1

#define LONG_MIN ((long)0x80000000L) // -2147483647 // - (2*31 - 1)

#define ULONG_MAX 0xFFFFFFFFUL // 4294967295 // 2*32 - 1

#define MB_LEN_MAX 1

#endif

2. Библиотека float.h

/* float.h

Defines implementation specific macros for dealing with

floating point.

Copyright (c) 1987, 1992 by Borland International

All Rights Reserved.

*/

#ifndef __FLOAT_H

#define __FLOAT_H

#if !defined(___DEFS_H)

#include <_defs>

#endif

#define FLT_RADIX 2

#define FLT_ROUNDS 1

#define FLT_GUARD 1

#define FLT_NORMALIZE 1

#define DBL_DIG 15

#define FLT_DIG 6

#define LDBL_DIG 19

#define DBL_MANT_DIG 53

#define FLT_MANT_DIG 24

#define LDBL_MANT_DIG 64

#define DBL_EPSILON 2.2204460492503131E-16

#define FLT_EPSILON 1.19209290E-07F

#define LDBL_EPSILON 1.084202172485504E-19

/* smallest positive IEEE normal numbers */

#define DBL_MIN 2.2250738585072014E-308

#define FLT_MIN 1.17549435E-38F

#define LDBL_MIN _tiny_ldble

#define DBL_MAX _huge_dble

#define FLT_MAX _huge_flt

#define LDBL_MAX _huge_ldble

#define DBL_MAX_EXP +1024

#define FLT_MAX_EXP +128

#define LDBL_MAX_EXP +16384

#define DBL_MAX_10_EXP +308

#define FLT_MAX_10_EXP +38

#define LDBL_MAX_10_EXP +4932

#define DBL_MIN_10_EXP -307

#define FLT_MIN_10_EXP -37

#define LDBL_MIN_10_EXP -4931

#define DBL_MIN_EXP -1021

#define FLT_MIN_EXP -125

#define LDBL_MIN_EXP -16381

extern float _Cdecl _huge_flt;

extern double _Cdecl _huge_dble;

extern long double _Cdecl _huge_ldble;

extern long double _Cdecl _tiny_ldble;

#ifdef __cplusplus

extern "C" {

#endif

unsigned int _Cdecl _FARFUNC _clear87(void);

unsigned int _Cdecl _FARFUNC _control87(unsigned int __newcw, unsigned int __mask);

void _Cdecl _FARFUNC _fpreset(void);

unsigned int _Cdecl _FARFUNC _status87(void);