├── .gitignore ├── tasks ├── oscript.cfg └── test.os ├── tests ├── oscript.cfg ├── bdd-assertions-tests-parallel.os ├── xunit-assertions-tests.os ├── bdd-assertions-tests-additional.os ├── ПроверкаКоллекцийКоллекшонос.os ├── bdd-assertions-tables-tests.os ├── test-detailed-errors.os ├── bdd-assertions-tests.os └── bdd-assertions-identity-tests.os ├── .vscode ├── settings.json └── tasks.json ├── src ├── Модули │ ├── Ожидаем.os │ └── Утверждения.os ├── Классы │ ├── ИсключениеОшибкаУтверждения.os │ └── БДДАссерт.os └── internal │ └── Модули │ └── УтвержденияСлужебный.os ├── .github ├── workflows │ ├── release.yml │ └── test.yml └── instructions │ └── copilot.instructions.md ├── packagedef ├── Jenkinsfile └── README.md /.gitignore: -------------------------------------------------------------------------------- 1 | oscript_modules/ 2 | 3 | tests\.xml 4 | *.ospx 5 | -------------------------------------------------------------------------------- /tasks/oscript.cfg: -------------------------------------------------------------------------------- 1 | lib.system=../oscript_modules 2 | SystemLanguage=ru 3 | -------------------------------------------------------------------------------- /tests/oscript.cfg: -------------------------------------------------------------------------------- 1 | lib.additional=../oscript_modules 2 | SystemLanguage=ru -------------------------------------------------------------------------------- /.vscode/settings.json: -------------------------------------------------------------------------------- 1 | // Place your settings in this file to overwrite default and user settings. 2 | { 3 | "editor.rulers": [120] 4 | } -------------------------------------------------------------------------------- /src/Модули/Ожидаем.os: -------------------------------------------------------------------------------- 1 | Функция Что(Знач ПроверяемоеЗначениеПараметр, Знач Сообщение = "") Экспорт 2 | БДДАссерт = Новый БДДАссерт(ПроверяемоеЗначениеПараметр, Сообщение); 3 | Возврат БДДАссерт; 4 | КонецФункции 5 | -------------------------------------------------------------------------------- /src/Классы/ИсключениеОшибкаУтверждения.os: -------------------------------------------------------------------------------- 1 | Перем Тип; 2 | 3 | Процедура ОбработкаПолученияПредставления(Представление, СтандартнаяОбработка) 4 | СтандартнаяОбработка = Ложь; 5 | Представление = СтрШаблон("{Тип = %1}", Тип); 6 | КонецПроцедуры 7 | 8 | Тип = "Ошибка утверждения"; 9 | -------------------------------------------------------------------------------- /.github/workflows/release.yml: -------------------------------------------------------------------------------- 1 | name: Публикация релиза 2 | 3 | on: 4 | release: 5 | types: 6 | - published 7 | workflow_dispatch: 8 | 9 | jobs: 10 | release: 11 | uses: autumn-library/workflows/.github/workflows/release.yml@v1 12 | with: 13 | package_mask: "asserts-*.ospx" 14 | secrets: 15 | PUSH_TOKEN: ${{ secrets.PUSH_TOKEN }} 16 | -------------------------------------------------------------------------------- /.github/instructions/copilot.instructions.md: -------------------------------------------------------------------------------- 1 | ## Общее 2 | 3 | Этот проект написан на языке 1С:Предприятие 8 и выполняется в независимой реализации виртуальной машины под названием OneScript или oscript. Документация доступна на сайте https://oscript.io, исходный код движка - https://github.com/EvilBeaver/OneScript 4 | 5 | 6 | ## Тестирование 7 | 8 | Для запуска тестов используется команда: 9 | 10 | ```sh 11 | oscript tasks/test.os 12 | ``` 13 | Не запускай тесты другим способом! -------------------------------------------------------------------------------- /.github/workflows/test.yml: -------------------------------------------------------------------------------- 1 | name: Тестирование 2 | 3 | on: 4 | push: 5 | pull_request: 6 | workflow_dispatch: 7 | 8 | jobs: 9 | test: 10 | strategy: 11 | matrix: 12 | oscript_version: ['default', 'lts-dev', 'dev'] 13 | test_engine: ['1testrunner'] 14 | include: 15 | - oscript_version: 'dev' 16 | test_engine: 'oneunit' 17 | uses: autumn-library/workflows/.github/workflows/test.yml@main 18 | with: 19 | oscript_version: ${{ matrix.oscript_version }} 20 | test_engine: ${{ matrix.test_engine }} 21 | -------------------------------------------------------------------------------- /packagedef: -------------------------------------------------------------------------------- 1 | 2 | Описание.Имя("asserts") 3 | .Версия("1.6.1") 4 | .ВерсияСреды("1.9.2") 5 | .ВключитьФайл("src") 6 | .ВключитьФайл("tests") 7 | .ВключитьФайл("readme.md") 8 | .ОпределяетКласс("БДДАссерт", "src/Классы/БДДАссерт.os") 9 | .ОпределяетКласс("ИсключениеОшибкаУтверждения", "src/Классы/ИсключениеОшибкаУтверждения.os") 10 | .ОпределяетМодуль("Ожидаем", "src/Модули/Ожидаем.os") 11 | .ОпределяетМодуль("Утверждения", "src/Модули/Утверждения.os") 12 | .РазработкаЗависитОт("1bdd") 13 | .РазработкаЗависитОт("1testrunner") 14 | .РазработкаЗависитОт("collectionos") 15 | -------------------------------------------------------------------------------- /src/internal/Модули/УтвержденияСлужебный.os: -------------------------------------------------------------------------------- 1 | Перем Рефлектор; 2 | Перем ИзвестныеТипыКоличество; 3 | Перем КоллекшоносЗагружен; 4 | 5 | Функция КоллекшоносЗагружен() Экспорт 6 | 7 | Если КоллекшоносЗагружен = Истина Тогда 8 | Возврат Истина; 9 | КонецЕсли; 10 | 11 | Рефлектор = Новый Рефлектор(); 12 | 13 | ИзвестныеТипы = Рефлектор.ИзвестныеТипы(); 14 | 15 | Если ИзвестныеТипыКоличество = ИзвестныеТипы.Количество() Тогда 16 | Возврат Ложь; 17 | КонецЕсли; 18 | 19 | ИзвестныеТипыКоличество = ИзвестныеТипы.Количество(); 20 | 21 | КоллекшоносЗагружен = ИзвестныеТипы.Найти("Обходимое", "Имя") <> Неопределено; 22 | 23 | Возврат КоллекшоносЗагружен; 24 | 25 | КонецФункции 26 | -------------------------------------------------------------------------------- /tests/bdd-assertions-tests-parallel.os: -------------------------------------------------------------------------------- 1 | &Тест 2 | Процедура ТестДолжен_Проверить_ОбработкуАссертовВФоновыхЗаданиях() Экспорт 3 | 4 | ФЗ = Новый Массив; 5 | 6 | Для Счетчик = 1 По 50 Цикл 7 | ФЗ.Добавить(ФоновыеЗадания.Выполнить(ЭтотОбъект, "ГенерацияОбъектовВЦикле")); 8 | КонецЦикла; 9 | 10 | Попытка 11 | ФоновыеЗадания.ОжидатьВсе(ФЗ); 12 | КоличествоОшибок = 0; 13 | Исключение 14 | Информация = ИнформацияОбОшибке(); 15 | КоличествоОшибок = Информация.Параметры.Количество(); 16 | КонецПопытки; 17 | 18 | Ожидаем.Что( 19 | КоличествоОшибок, 20 | СтрШаблон("При обработке ассертов в фоновом задании ошибки %1", КоличествоОшибок) 21 | ).Равно(0); 22 | 23 | КонецПроцедуры 24 | 25 | Процедура ГенерацияОбъектовВЦикле() Экспорт 26 | Для сч = 1 По 50 Цикл 27 | ОбъектМассив = Новый Массив(); 28 | Ожидаем.Что( 29 | ОбъектМассив, 30 | СтрШаблон("Проблема в определении значения ""Неопределено"" %1", Сч) 31 | ).Не_().Равно(Неопределено); 32 | КонецЦикла; 33 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/xunit-assertions-tests.os: -------------------------------------------------------------------------------- 1 | &Тест 2 | Процедура ТестДолжен_Проверить_МетодСуществует_НеВыбрасываетИсключениеДляСуществующегоМетода() Экспорт 3 | Попытка 4 | Утверждения.ПроверитьМетодСуществует(Новый Массив, "Добавить"); 5 | Исключение 6 | ВызватьИсключение ОписаниеОшибки() + ". Проверка существующего метода вызвала исключение, хотя не должна была"; 7 | КонецПопытки; 8 | КонецПроцедуры 9 | 10 | &Тест 11 | Процедура ТестДолжен_Проверить_МетодСуществует_ВыбрасываетИсключениеДляОтсутствующегоМетода() Экспорт 12 | Попытка 13 | Утверждения.ПроверитьМетодСуществует(Новый Массив, "ТакогоИмениМетодаНеДолжноБыть"); 14 | Исключение 15 | Возврат; 16 | КонецПопытки; 17 | 18 | // тест должен завершиться в обработке исключения 19 | // если дошло сюда - это ошибка 20 | ВызватьИсключение "Проверка существования у объекта несуществующего метода должна была выбросить исключение, но этого не произошло"; 21 | КонецПроцедуры 22 | 23 | &Тест 24 | Процедура ТестДолжен_Проверить_МетодСуществует_ВыбрасываетИсключениеСУказаннымТекстом() Экспорт 25 | Перем ЧастьТекста; 26 | 27 | ЧастьТекста = "ЭтотТекстДолженБытьВТекстеИсключения*#1~"; 28 | Попытка 29 | Утверждения.ПроверитьМетодСуществует(Новый Массив, "ТакогоИмениМетодаНеДолжноБыть", ЧастьТекста); 30 | Исключение 31 | Если 0 = СтрНайти(ОписаниеОшибки(), ЧастьТекста) Тогда 32 | ВызватьИсключение ОписаниеОшибки() + ". Текст исключения не содержит ожидаемого текста"; 33 | Иначе 34 | Возврат; 35 | КонецЕсли; 36 | КонецПопытки; 37 | 38 | // тест должен завершиться в обработке исключения 39 | // если дошло сюда - это ошибка 40 | ВызватьИсключение "Проверка отсутствующего метода должна была выбросить исключение, но этого не произошло"; 41 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/bdd-assertions-tests-additional.os: -------------------------------------------------------------------------------- 1 | &Тест 2 | Процедура ТестДолжен_Проверить_ИмеетМетод_НеВыбрасываетИсключениеДляСуществующегоМетода() Экспорт 3 | Ожидаем 4 | .Что(Новый Массив) 5 | .ИмеетМетод("Добавить") 6 | ; 7 | КонецПроцедуры 8 | 9 | &Тест 10 | Процедура ТестДолжен_Проверить_ИмеетМетод_ВыбрасываетИсключениеДляОтсутствующегоМетода() Экспорт 11 | Попытка 12 | Ожидаем 13 | .Что(Новый Массив) 14 | .ИмеетМетод("ТакогоИмениМетодаНеДолжноБыть"); 15 | Исключение 16 | Возврат; 17 | КонецПопытки; 18 | 19 | // тест должен завершиться в обработке исключения 20 | // если дошло сюда - это ошибка 21 | ВызватьИсключение "Проверка существования у объекта несуществующего метода должна была выбросить исключение, но этого не произошло"; 22 | КонецПроцедуры 23 | 24 | &Тест 25 | Процедура ТестДолжен_Проверить_ИмеетМетод_ВыбрасываетИсключениеСУказаннымТекстом() Экспорт 26 | Перем ЧастьТекста, Сообщение; 27 | 28 | ЧастьТекста = "ЭтотТекстДолженБытьВТекстеИсключения*#1~"; 29 | Попытка 30 | Ожидаем 31 | .Что(Новый Массив, ЧастьТекста) 32 | .ИмеетМетод("ТакогоИмениМетодаНеДолжноБыть"); 33 | Исключение 34 | Если 0 = СтрНайти(ОписаниеОшибки(), ЧастьТекста) Тогда 35 | Сообщение = "Ожидали, что проверка наличия несуществующего метода у объекта выбросит исключение с указанным текстом, но текст не был найден в тексте исключения" + Символы.ПС 36 | + "Ожидаемый текст: " + ЧастьТекста + Символы.ПС 37 | + "Текст исключения: " + ОписаниеОшибки(); 38 | ВызватьИсключение Сообщение; 39 | Иначе 40 | Возврат; 41 | КонецЕсли; 42 | КонецПопытки; 43 | 44 | // тест должен завершиться в обработке исключения 45 | // если дошло сюда - это ошибка 46 | ВызватьИсключение "Проверка существования у объекта несуществующего метода должна была выбросить исключение, но этого не произошло"; 47 | КонецПроцедуры 48 | 49 | &Тест 50 | Процедура ТестДолжен_Проверить_ИмеетМетод_ПоддерживаетОтрицание() Экспорт 51 | Попытка 52 | Ожидаем 53 | .Что(Новый Массив) 54 | .Не_() 55 | .ИмеетМетод("ТакогоИмениМетодаНеДолжноБыть"); 56 | Исключение 57 | ВызватьИсключение "Ожидали, что проверка существования метода совместно с отрицанием не выбросит исключение. " + ОписаниеОшибки(); 58 | КонецПопытки; 59 | КонецПроцедуры 60 | 61 | &Тест 62 | Процедура ТестДолжен_Проверить_ИмеетМетод_ПоддерживаетЦепныеВызовы() Экспорт 63 | Если ТипЗнч(Ожидаем.Что(Новый Массив).ИмеетМетод("Добавить")) <> Тип("БДДАссерт") Тогда 64 | ВызватьИсключение "Ожидали, что метод ИмеетМетод() поддерживает цепные вызовы (возвращает объект)"; 65 | КонецЕсли; 66 | КонецПроцедуры -------------------------------------------------------------------------------- /Jenkinsfile: -------------------------------------------------------------------------------- 1 | 2 | pipeline { 3 | agent none 4 | options { 5 | buildDiscarder(logRotator(numToKeepStr: '7')) 6 | skipDefaultCheckout() 7 | } 8 | 9 | stages { 10 | stage('Тестирование кода пакета WIN') { 11 | 12 | agent { label 'windows' } 13 | 14 | steps { 15 | checkout scm 16 | 17 | script { 18 | if( fileExists ('tasks/test.os') ){ 19 | bat 'chcp 65001 > nul && oscript tasks/test.os' 20 | junit 'tests.xml' 21 | junit 'bdd-log.xml' 22 | } 23 | else 24 | echo 'no testing task' 25 | } 26 | 27 | } 28 | 29 | } 30 | 31 | stage('Тестирование кода пакета LINUX') { 32 | 33 | agent { label 'master' } 34 | 35 | steps { 36 | echo 'under development' 37 | } 38 | 39 | } 40 | 41 | stage('Сборка пакета') { 42 | 43 | agent { label 'windows' } 44 | 45 | steps { 46 | checkout scm 47 | 48 | bat 'erase /Q *.ospx' 49 | bat 'chcp 65001 > nul && call opm build .' 50 | 51 | stash includes: '*.ospx', name: 'package' 52 | archiveArtifacts '*.ospx' 53 | } 54 | 55 | } 56 | 57 | stage('Публикация в хабе') { 58 | when { 59 | branch 'master' 60 | } 61 | agent { label 'master' } 62 | steps { 63 | sh 'rm -f *.ospx' 64 | unstash 'package' 65 | 66 | sh ''' 67 | artifact=`ls -1 *.ospx` 68 | basename=`echo $artifact | sed -r 's/(.+)-.*(.ospx)/\\1/'` 69 | cp $artifact $basename.ospx 70 | sudo rsync -rv *.ospx /var/www/hub.oscript.io/download/$basename/ 71 | '''.stripIndent() 72 | } 73 | } 74 | 75 | stage('Публикация в нестабильном хабе') { 76 | when { 77 | branch 'develop' 78 | } 79 | agent { label 'master' } 80 | steps { 81 | sh 'rm -f *.ospx' 82 | unstash 'package' 83 | 84 | sh ''' 85 | artifact=`ls -1 *.ospx` 86 | basename=`echo $artifact | sed -r 's/(.+)-.*(.ospx)/\\1/'` 87 | cp $artifact $basename.ospx 88 | sudo rsync -rv *.ospx /var/www/hub.oscript.io/dev-channel/$basename/ 89 | '''.stripIndent() 90 | } 91 | } 92 | } 93 | } 94 | -------------------------------------------------------------------------------- /tasks/test.os: -------------------------------------------------------------------------------- 1 | #Использовать ".." 2 | #Использовать 1bdd 3 | #Использовать 1testrunner 4 | 5 | Функция ПрогнатьТесты() 6 | 7 | Тестер = Новый Тестер; 8 | 9 | ПутьКТестам = ОбъединитьПути(ТекущийСценарий().Каталог, "..", "tests"); 10 | 11 | Файл_ПутьКТестам = Новый Файл(ПутьКТестам); 12 | Если Не Файл_ПутьКТестам.Существует() Тогда 13 | Возврат Истина; 14 | КонецЕсли; 15 | 16 | ПутьКОтчетуJUnit = ОбъединитьПути(ТекущийСценарий().Каталог, ".."); 17 | 18 | РезультатТестирования = Тестер.ТестироватьКаталог( 19 | Новый Файл(ПутьКТестам), 20 | Новый Файл(ПутьКОтчетуJUnit) 21 | ); 22 | 23 | Успешно = РезультатТестирования = 0; 24 | 25 | Возврат Успешно; 26 | КонецФункции // ПрогнатьТесты() 27 | 28 | Функция ПрогнатьФичи() 29 | 30 | ПутьОтчетаJUnit = "./bdd-log.xml"; 31 | 32 | КаталогФич = ОбъединитьПути(ТекущийСценарий().Каталог, ".", "features"); 33 | 34 | ИсполнительБДД = Новый ИсполнительБДД; 35 | 36 | Файл_КаталогФич = Новый Файл(КаталогФич); 37 | Если Не Файл_КаталогФич.Существует() Тогда 38 | Возврат Истина; 39 | КонецЕсли; 40 | 41 | РезультатыВыполнения = ИсполнительБДД.ВыполнитьФичу(Файл_КаталогФич, Файл_КаталогФич); 42 | ИтоговыйРезультатВыполнения = ИсполнительБДД.ПолучитьИтоговыйСтатусВыполнения(РезультатыВыполнения); 43 | 44 | СтатусВыполнения = ИсполнительБДД.ВозможныеСтатусыВыполнения().НеВыполнялся; 45 | Если РезультатыВыполнения.Строки.Количество() > 0 Тогда 46 | 47 | СтатусВыполнения = ИсполнительБДД.ПолучитьИтоговыйСтатусВыполнения(РезультатыВыполнения); 48 | 49 | КонецЕсли; 50 | 51 | ГенераторОтчетаJUnit = Новый ГенераторОтчетаJUnit; 52 | ГенераторОтчетаJUnit.Сформировать(РезультатыВыполнения, СтатусВыполнения, ПутьОтчетаJUnit); 53 | 54 | Сообщить(СтрШаблон("Результат прогона фич <%1> 55 | |", ИтоговыйРезультатВыполнения)); 56 | 57 | Возврат ИтоговыйРезультатВыполнения <> ИсполнительБДД.ВозможныеСтатусыВыполнения().Сломался; 58 | КонецФункции // ПрогнатьФичи() 59 | 60 | Попытка 61 | ТестыПрошли = ПрогнатьТесты(); 62 | 63 | Исключение 64 | ТестыПрошли = Ложь; 65 | Сообщить(СтрШаблон("Тесты через 1testrunner выполнены неудачно 66 | |%1", ПодробноеПредставлениеОшибки(ИнформацияОбОшибке()))); 67 | КонецПопытки; 68 | 69 | Попытка 70 | ФичиПрошли = ПрогнатьФичи(); 71 | Исключение 72 | ФичиПрошли = Ложь; 73 | Сообщить(СтрШаблон("Тесты поведения через 1bdd выполнены неудачно 74 | |%1", ПодробноеПредставлениеОшибки(ИнформацияОбОшибке()))); 75 | КонецПопытки; 76 | 77 | Если Не ТестыПрошли Или Не ФичиПрошли Тогда 78 | ВызватьИсключение "Тестирование завершилось неудачно!"; 79 | Иначе 80 | Сообщить(СтрШаблон("Результат прогона тестов <%1> 81 | |", ТестыПрошли)); 82 | КонецЕсли; 83 | 84 | // Если РезультатТестирования <> 0 Тогда 85 | // ВызватьИсключение РезультатТестирования; 86 | // КонецЕсли; 87 | 88 | // Если ИтоговыйРезультатВыполнения = ИсполнительБДД.ВозможныеСтатусыВыполнения().Сломался Тогда 89 | 90 | // ВызватьИсключение 1; 91 | 92 | // КонецЕсли; 93 | -------------------------------------------------------------------------------- /tests/ПроверкаКоллекцийКоллекшонос.os: -------------------------------------------------------------------------------- 1 | #Использовать ".." 2 | #Использовать collectionos 3 | 4 | &Тест 5 | Процедура ОжидаемСодержитВСписке() Экспорт 6 | 7 | // Дано 8 | Список = Новый СписокМассив; 9 | Список.Добавить(1); 10 | 11 | // Когда 12 | Ожидаем.Что(Список) 13 | .Содержит(1); 14 | 15 | // Тогда 16 | 17 | КонецПроцедуры 18 | 19 | &Тест 20 | Процедура ОжидаемНеСодержитВСписке() Экспорт 21 | 22 | // Дано 23 | БылоИсключение = Ложь; 24 | 25 | Список = Новый СписокМассив; 26 | Список.Добавить(2); 27 | 28 | // Когда 29 | Попытка 30 | Ожидаем.Что(Список) 31 | .Содержит(1); 32 | Исключение 33 | БылоИсключение = Истина; 34 | ОписаниеОшибки = ОписаниеОшибки(); 35 | КонецПопытки; 36 | 37 | // Тогда 38 | ПроверитьИсключение( 39 | БылоИсключение, 40 | ОписаниеОшибки, 41 | "Ожидали, что проверяемое значение ([2]) СОДЕРЖИТ (1)" 42 | ); 43 | 44 | КонецПроцедуры 45 | 46 | &Тест 47 | Процедура ОжидаемСодержитВМножестве() Экспорт 48 | 49 | // Дано 50 | Множество = Новый МножествоСоответствие; 51 | Множество.Добавить(1); 52 | 53 | // Когда 54 | Ожидаем.Что(Множество) 55 | .Содержит(1); 56 | 57 | // Тогда 58 | 59 | КонецПроцедуры 60 | 61 | &Тест 62 | Процедура ОжидаемНеСодержитВМножестве() Экспорт 63 | 64 | // Дано 65 | БылоИсключение = Ложь; 66 | 67 | Множество = Новый МножествоСоответствие; 68 | Множество.Добавить(2); 69 | 70 | // Когда 71 | Попытка 72 | Ожидаем.Что(Множество) 73 | .Содержит(1); 74 | Исключение 75 | БылоИсключение = Истина; 76 | ОписаниеОшибки = ОписаниеОшибки(); 77 | КонецПопытки; 78 | 79 | // Тогда 80 | ПроверитьИсключение( 81 | БылоИсключение, 82 | ОписаниеОшибки, 83 | "Ожидали, что проверяемое значение ([2]) СОДЕРЖИТ (1)" 84 | ); 85 | 86 | КонецПроцедуры 87 | 88 | &Тест 89 | Процедура ОжидаемСодержитВОчереди() Экспорт 90 | 91 | // Дано 92 | Очередь = Новый ОчередьМассив; 93 | Очередь.Добавить(1); 94 | 95 | // Когда 96 | Ожидаем.Что(Очередь) 97 | .Содержит(1); 98 | 99 | // Тогда 100 | 101 | КонецПроцедуры 102 | 103 | &Тест 104 | Процедура ОжидаемНеСодержитВОчереди() Экспорт 105 | 106 | // Дано 107 | БылоИсключение = Ложь; 108 | 109 | Очередь = Новый ОчередьМассив; 110 | Очередь.Добавить(2); 111 | 112 | // Когда 113 | Попытка 114 | Ожидаем.Что(Очередь) 115 | .Содержит(1); 116 | Исключение 117 | БылоИсключение = Истина; 118 | ОписаниеОшибки = ОписаниеОшибки(); 119 | КонецПопытки; 120 | 121 | // Тогда 122 | ПроверитьИсключение( 123 | БылоИсключение, 124 | ОписаниеОшибки, 125 | "Ожидали, что проверяемое значение ([2]) СОДЕРЖИТ (1)" 126 | ); 127 | 128 | КонецПроцедуры 129 | 130 | &Тест 131 | Процедура ОжидаемСодержитВКарте() Экспорт 132 | 133 | // Дано 134 | Карта = Новый КартаСоответствие; 135 | Карта.Вставить(1, 1); 136 | 137 | // Когда 138 | Ожидаем.Что(Карта) 139 | .Содержит(1); 140 | 141 | // Тогда 142 | 143 | КонецПроцедуры 144 | 145 | &Тест 146 | Процедура ОжидаемНеСодержитВКарте() Экспорт 147 | 148 | // Дано 149 | БылоИсключение = Ложь; 150 | 151 | Карта = Новый КартаСоответствие; 152 | Карта.Вставить(1, 2); 153 | 154 | // Когда 155 | Попытка 156 | Ожидаем.Что(Карта) 157 | .Содержит(1); 158 | Исключение 159 | БылоИсключение = Истина; 160 | ОписаниеОшибки = ОписаниеОшибки(); 161 | КонецПопытки; 162 | 163 | // Тогда 164 | ПроверитьИсключение( 165 | БылоИсключение, 166 | ОписаниеОшибки, 167 | "Ожидали, что проверяемое значение ({1=2}) СОДЕРЖИТ (1)" 168 | ); 169 | 170 | КонецПроцедуры 171 | 172 | Процедура ПроверитьИсключение(БылоИсключение, ОписаниеОшибки, ИскомыйТекстИсключения) 173 | 174 | Контекст = Новый ИсключениеОшибкаУтверждения(); 175 | 176 | Если Не БылоИсключение Тогда 177 | 178 | ВызватьИсключение Новый ИнформацияОбОшибке( 179 | "Ожидали, что будет исключение а это не так", 180 | Контекст 181 | ); 182 | 183 | КонецЕсли; 184 | 185 | Если СтрНайти(ОписаниеОшибки, ИскомыйТекстИсключения) = 0 Тогда 186 | 187 | ВызватьИсключение Новый ИнформацияОбОшибке( 188 | СтрШаблон( 189 | "Ожидали, что в тексте ошибки будет текст: { %1 }, а был { %2 }", 190 | ИскомыйТекстИсключения, 191 | ОписаниеОшибки 192 | ), 193 | Контекст 194 | ); 195 | 196 | КонецЕсли; 197 | 198 | КонецПроцедуры 199 | -------------------------------------------------------------------------------- /tests/bdd-assertions-tables-tests.os: -------------------------------------------------------------------------------- 1 | &Тест 2 | Процедура ТестДолжен_Проверить_РавнаТаблице() Экспорт 3 | Ожидаем.Что(Таблица1()).РавнаТаблице(Таблица1()); 4 | КонецПроцедуры 5 | 6 | &Тест 7 | Процедура ТестДолжен_Проверить_Отрицание_РавнаТаблице() Экспорт 8 | Ожидаем.Что(Таблица1()).Не_().РавнаТаблице(Таблица2()); 9 | КонецПроцедуры 10 | 11 | &Тест 12 | Процедура ТестДолжен_Проверить_ИмеетРавнуюСтруктуруСТаблицей() Экспорт 13 | Таблица2 = Таблица1(); 14 | Таблица2.Удалить(0); 15 | Ожидаем.Что(Таблица1()).ИмеетРавнуюСтруктуруСТаблицей(Таблица2); 16 | КонецПроцедуры 17 | 18 | &Тест 19 | Процедура ТестДолжен_Проверить_ИмеетРавнуюСтруктуруСТаблицей_БезУчетаПорядкаКолонок() Экспорт 20 | Ожидаем.Что(Таблица1()).БезУчетаПорядКаКолонок().ИмеетРавнуюСтруктуруСТаблицей(Таблица3()); 21 | КонецПроцедуры 22 | 23 | &Тест 24 | Процедура ТестДолжен_Проверить_Отрицание_ИмеетРавнуюСтруктуруСТаблицей() Экспорт 25 | Ожидаем.Что(Таблица1()).Не_().ИмеетРавнуюСтруктуруСТаблицей(Таблица3()); 26 | КонецПроцедуры 27 | 28 | &Тест 29 | Процедура ТестДолжен_Проверить_НеравенствоТаблицСИзмененнымПорядкомСтрок() Экспорт 30 | Таблица2 = Таблица1(); 31 | Таблица2.Сортировать("К1 УБЫВ"); 32 | Ожидаем.Что(Таблица1()).Не_().РавнаТаблице(Таблица2); 33 | КонецПроцедуры 34 | 35 | &Тест 36 | Процедура ТестДолжен_Проверить_НеравенствоТаблицСИзмененнымПорядкомКолонок() Экспорт 37 | Ожидаем.Что(Таблица1()).Не_().РавнаТаблице(Таблица3()); 38 | КонецПроцедуры 39 | 40 | &Тест 41 | Процедура ТестДолжен_Проверить_НеравенствоТаблицСРазнымСоставомКолонок() Экспорт 42 | Таблица2 = Таблица1(); 43 | Таблица2.Колонки.К1.Имя = "КК"; 44 | Ожидаем.Что(Таблица1()).Не_().РавнаТаблице(Таблица2); 45 | КонецПроцедуры 46 | 47 | &Тест 48 | Процедура ТестДолжен_Проверить_СодержитСтрокуТаблицы() Экспорт 49 | СтрокаТаблицы = Таблица1()[0]; 50 | Ожидаем.Что(Таблица1()).СодержитСтрокуТаблицы(СтрокаТаблицы); 51 | КонецПроцедуры 52 | 53 | &Тест 54 | Процедура ТестДолжен_Проверить_Отрицание_СодержитСТрокуТаблицы() Экспорт 55 | СтрокаТаблицы = Таблица1()[0]; 56 | СтрокаТаблицы.К0 = "777"; 57 | Ожидаем.Что(Таблица1()).Не_().СодержитСтрокуТаблицы(СтрокаТаблицы); 58 | КонецПроцедуры 59 | 60 | &Тест 61 | Процедура ТестДолжен_Проверить_РавнаТаблице_БезУчетаПорядкаСтрок() Экспорт 62 | Таблица2 = Таблица1(); 63 | Таблица2.Сортировать("К1 УБЫВ"); 64 | Ожидаем.Что(Таблица1()).БезУчетаПорядкаСтрок().РавнаТаблице(Таблица2); 65 | КонецПроцедуры 66 | 67 | &Тест 68 | Процедура ТестДолжен_Проверить_РавнаТаблице_БезУчетаПорядкаКолонок() Экспорт 69 | Ожидаем.Что(Таблица1()).БезУчетаПорядкаКолонок().РавнаТаблице(Таблица3()); 70 | КонецПроцедуры 71 | 72 | &Тест 73 | Процедура ТестДолжен_Проверить_РавнаТаблице_БезУчетаИменКолонок() Экспорт 74 | Ожидаем.Что(Таблица1()).БезУчетаИменКолонок().РавнаТаблице(Таблица2()); 75 | КонецПроцедуры 76 | 77 | // helpers 78 | Функция Таблица1() 79 | 80 | ТЗ = Новый ТаблицаЗначений; 81 | ТЗ.Колонки.Добавить("К0"); 82 | ТЗ.Колонки.Добавить("К1"); 83 | ТЗ.Колонки.Добавить("К2"); 84 | 85 | СтрТЗ = ТЗ.Добавить(); 86 | СтрТЗ.К0 = "11"; 87 | СтрТЗ.К1 = "12"; 88 | СтрТЗ.К2 = "13"; 89 | 90 | СтрТЗ = ТЗ.Добавить(); 91 | СтрТЗ.К0 = "21"; 92 | СтрТЗ.К1 = "22"; 93 | СтрТЗ.К2 = "23"; 94 | 95 | СтрТЗ = ТЗ.Добавить(); 96 | СтрТЗ.К0 = "31"; 97 | СтрТЗ.К1 = "32"; 98 | СтрТЗ.К2 = "33"; 99 | 100 | Возврат ТЗ; 101 | КонецФункции 102 | 103 | Функция Таблица2() 104 | 105 | ТЗ = Новый ТаблицаЗначений; 106 | ТЗ.Колонки.Добавить("А0"); 107 | ТЗ.Колонки.Добавить("А1"); 108 | ТЗ.Колонки.Добавить("А2"); 109 | 110 | СтрТЗ = ТЗ.Добавить(); 111 | СтрТЗ.А0 = "11"; 112 | СтрТЗ.А1 = "12"; 113 | СтрТЗ.А2 = "13"; 114 | 115 | СтрТЗ = ТЗ.Добавить(); 116 | СтрТЗ.А0 = "21"; 117 | СтрТЗ.А1 = "22"; 118 | СтрТЗ.А2 = "23"; 119 | 120 | СтрТЗ = ТЗ.Добавить(); 121 | СтрТЗ.А0 = "31"; 122 | СтрТЗ.А1 = "32"; 123 | СтрТЗ.А2 = "33"; 124 | 125 | Возврат ТЗ; 126 | КонецФункции 127 | 128 | Функция Таблица3() 129 | 130 | ТЗ = Новый ТаблицаЗначений; 131 | ТЗ.Колонки.Добавить("К0"); 132 | ТЗ.Колонки.Добавить("К2"); 133 | ТЗ.Колонки.Добавить("К1"); 134 | 135 | СтрТЗ = ТЗ.Добавить(); 136 | СтрТЗ.К0 = "11"; 137 | СтрТЗ.К1 = "12"; 138 | СтрТЗ.К2 = "13"; 139 | 140 | СтрТЗ = ТЗ.Добавить(); 141 | СтрТЗ.К0 = "21"; 142 | СтрТЗ.К1 = "22"; 143 | СтрТЗ.К2 = "23"; 144 | 145 | СтрТЗ = ТЗ.Добавить(); 146 | СтрТЗ.К0 = "31"; 147 | СтрТЗ.К1 = "32"; 148 | СтрТЗ.К2 = "33"; 149 | 150 | Возврат ТЗ; 151 | КонецФункции -------------------------------------------------------------------------------- /tests/test-detailed-errors.os: -------------------------------------------------------------------------------- 1 | &Тест 2 | Процедура ТестДетализацииОшибокВМассивах() Экспорт 3 | 4 | // Тест различия типов 5 | Попытка 6 | Ожидаем.Что("строка").РавноМассиву(Новый Массив); 7 | ВызватьИсключение "Исключение должно было возникнуть"; 8 | Исключение 9 | СообщениеОбОшибке = ОписаниеОшибки(); 10 | Ожидаем.Что(СообщениеОбОшибке).Содержит("ожидался массив, но получен"); 11 | КонецПопытки; 12 | 13 | // Тест различия количества элементов 14 | Массив1 = Новый Массив; 15 | Массив1.Добавить(1); 16 | Массив1.Добавить(2); 17 | 18 | Массив2 = Новый Массив; 19 | Массив2.Добавить(1); 20 | 21 | Попытка 22 | Ожидаем.Что(Массив1).РавноМассиву(Массив2); 23 | ВызватьИсключение "Исключение должно было возникнуть"; 24 | Исключение 25 | СообщениеОбОшибке = ОписаниеОшибки(); 26 | Ожидаем.Что(СообщениеОбОшибке).Содержит("разное количество элементов"); 27 | Ожидаем.Что(СообщениеОбОшибке).Содержит("ожидалось 1, получено 2"); 28 | КонецПопытки; 29 | 30 | // Тест различия в конкретном элементе массива 31 | Массив1 = Новый Массив; 32 | Массив1.Добавить(1); 33 | Массив1.Добавить(999); // Различие здесь 34 | Массив1.Добавить(3); 35 | 36 | Массив2 = Новый Массив; 37 | Массив2.Добавить(1); 38 | Массив2.Добавить(2); // Ожидается 2 39 | Массив2.Добавить(3); 40 | 41 | Попытка 42 | Ожидаем.Что(Массив1).РавноМассиву(Массив2); 43 | ВызватьИсключение "Исключение должно было возникнуть"; 44 | Исключение 45 | СообщениеОбОшибке = ОписаниеОшибки(); 46 | Ожидаем.Что(СообщениеОбОшибке).Содержит("[1]"); // Индекс элемента 47 | Ожидаем.Что(СообщениеОбОшибке).Содержит("ожидалось 2, получено 999"); 48 | КонецПопытки; 49 | 50 | КонецПроцедуры 51 | 52 | &Тест 53 | Процедура ТестДетализацииОшибокВСтруктурах() Экспорт 54 | 55 | // Тест различия типов 56 | Попытка 57 | Ожидаем.Что("строка").РавноСтруктуреИлиСоответствию(Новый Структура); 58 | ВызватьИсключение "Исключение должно было возникнуть"; 59 | Исключение 60 | СообщениеОбОшибке = ОписаниеОшибки(); 61 | Ожидаем.Что(СообщениеОбОшибке).Содержит("ожидался").Содержит("получен"); 62 | КонецПопытки; 63 | 64 | // Тест отсутствующего ключа 65 | Структура1 = Новый Структура("Ключ1, Ключ2", 1, 2); 66 | Структура2 = Новый Структура("Ключ1, Ключ3", 1, 3); // Ключ2 отсутствует, есть Ключ3 67 | 68 | Попытка 69 | Ожидаем.Что(Структура1).РавноСтруктуреИлиСоответствию(Структура2); 70 | ВызватьИсключение "Исключение должно было возникнуть"; 71 | Исключение 72 | СообщениеОбОшибке = ОписаниеОшибки(); 73 | // Может быть либо отсутствие Ключ3, либо лишний Ключ2 74 | Условие = Найти(СообщениеОбОшибке, ".Ключ3") > 0 Или Найти(СообщениеОбОшибке, ".Ключ2") > 0; 75 | Ожидаем.Что(Условие).Равно(Истина); 76 | КонецПопытки; 77 | 78 | // Тест различия в значении ключа 79 | Структура1 = Новый Структура("Поле1, Поле2", "значение1", 999); // Различие в Поле2 80 | Структура2 = Новый Структура("Поле1, Поле2", "значение1", 555); // Ожидается 555 81 | 82 | Попытка 83 | Ожидаем.Что(Структура1).РавноСтруктуреИлиСоответствию(Структура2); 84 | ВызватьИсключение "Исключение должно было возникнуть"; 85 | Исключение 86 | СообщениеОбОшибке = ОписаниеОшибки(); 87 | Ожидаем.Что(СообщениеОбОшибке).Содержит(".Поле2"); // Ключ элемента 88 | Ожидаем.Что(СообщениеОбОшибке).Содержит("ожидалось 555, получено 999"); 89 | КонецПопытки; 90 | 91 | КонецПроцедуры 92 | 93 | &Тест 94 | Процедура ТестДетализацииОшибокВложенныхСтруктур() Экспорт 95 | 96 | // Тест вложенных структур 97 | ВнутренняяСтруктура1 = Новый Структура("ВнутреннийКлюч", 999); // Различие здесь 98 | ВнутренняяСтруктура2 = Новый Структура("ВнутреннийКлюч", 123); // Ожидается 123 99 | 100 | ВнешняяСтруктура1 = Новый Структура("ВнешнийКлюч", ВнутренняяСтруктура1); 101 | ВнешняяСтруктура2 = Новый Структура("ВнешнийКлюч", ВнутренняяСтруктура2); 102 | 103 | Попытка 104 | Ожидаем.Что(ВнешняяСтруктура1).РавноСтруктуреИлиСоответствию(ВнешняяСтруктура2); 105 | ВызватьИсключение "Исключение должно было возникнуть"; 106 | Исключение 107 | СообщениеОбОшибке = ОписаниеОшибки(); 108 | Ожидаем.Что(СообщениеОбОшибке).Содержит(".ВнешнийКлюч.ВнутреннийКлюч"); // Полный путь 109 | Ожидаем.Что(СообщениеОбОшибке).Содержит("ожидалось 123, получено 999"); 110 | КонецПопытки; 111 | 112 | КонецПроцедуры 113 | 114 | &Тест 115 | Процедура ТестДетализацииОшибокВложенныхМассивов() Экспорт 116 | 117 | // Тест массива массивов 118 | ВнутреннийМассив1 = Новый Массив; 119 | ВнутреннийМассив1.Добавить(1); 120 | ВнутреннийМассив1.Добавить(999); // Различие здесь 121 | 122 | ВнутреннийМассив2 = Новый Массив; 123 | ВнутреннийМассив2.Добавить(1); 124 | ВнутреннийМассив2.Добавить(2); // Ожидается 2 125 | 126 | ВнешнийМассив1 = Новый Массив; 127 | ВнешнийМассив1.Добавить("строка"); 128 | ВнешнийМассив1.Добавить(ВнутреннийМассив1); 129 | 130 | ВнешнийМассив2 = Новый Массив; 131 | ВнешнийМассив2.Добавить("строка"); 132 | ВнешнийМассив2.Добавить(ВнутреннийМассив2); 133 | 134 | Попытка 135 | Ожидаем.Что(ВнешнийМассив1).РавноМассиву(ВнешнийМассив2); 136 | ВызватьИсключение "Исключение должно было возникнуть"; 137 | Исключение 138 | СообщениеОбОшибке = ОписаниеОшибки(); 139 | Ожидаем.Что(СообщениеОбОшибке).Содержит("[1][1]"); // Полный путь с индексами 140 | Ожидаем.Что(СообщениеОбОшибке).Содержит("ожидалось 2, получено 999"); 141 | КонецПопытки; 142 | 143 | КонецПроцедуры 144 | 145 | &Тест 146 | Процедура ТестДетализацииОшибокСмешанныхТипов() Экспорт 147 | 148 | // Тест структуры с массивом 149 | МассивВСтруктуре1 = Новый Массив; 150 | МассивВСтруктуре1.Добавить("элемент1"); 151 | МассивВСтруктуре1.Добавить(999); // Различие здесь 152 | 153 | МассивВСтруктуре2 = Новый Массив; 154 | МассивВСтруктуре2.Добавить("элемент1"); 155 | МассивВСтруктуре2.Добавить(555); // Ожидается 555 156 | 157 | Структура1 = Новый Структура("Массив", МассивВСтруктуре1); 158 | Структура2 = Новый Структура("Массив", МассивВСтруктуре2); 159 | 160 | Попытка 161 | Ожидаем.Что(Структура1).РавноСтруктуреИлиСоответствию(Структура2); 162 | ВызватьИсключение "Исключение должно было возникнуть"; 163 | Исключение 164 | СообщениеОбОшибке = ОписаниеОшибки(); 165 | Ожидаем.Что(СообщениеОбОшибке).Содержит(".Массив[1]"); // Путь структура -> массив -> индекс 166 | Ожидаем.Что(СообщениеОбОшибке).Содержит("ожидалось 555, получено 999"); 167 | КонецПопытки; 168 | 169 | КонецПроцедуры 170 | 171 | &Тест 172 | Процедура ТестДетализацииОшибокВСоответствиях() Экспорт 173 | 174 | // Тест различия в значении ключа соответствия 175 | Соответствие1 = Новый Соответствие; 176 | Соответствие1.Вставить("Ключ1", "значение1"); 177 | Соответствие1.Вставить("Ключ2", 999); // Различие здесь 178 | 179 | Соответствие2 = Новый Соответствие; 180 | Соответствие2.Вставить("Ключ1", "значение1"); 181 | Соответствие2.Вставить("Ключ2", 777); // Ожидается 777 182 | 183 | Попытка 184 | Ожидаем.Что(Соответствие1).РавноСтруктуреИлиСоответствию(Соответствие2); 185 | ВызватьИсключение "Исключение должно было возникнуть"; 186 | Исключение 187 | СообщениеОбОшибке = ОписаниеОшибки(); 188 | Ожидаем.Что(СообщениеОбОшибке).Содержит(".Ключ2"); // Ключ элемента 189 | Ожидаем.Что(СообщениеОбОшибке).Содержит("ожидалось 777, получено 999"); 190 | КонецПопытки; 191 | 192 | КонецПроцедуры 193 | 194 | 195 | -------------------------------------------------------------------------------- /.vscode/tasks.json: -------------------------------------------------------------------------------- 1 | { 2 | "version": "0.1.0", 3 | "windows": { 4 | "command": "cmd", 5 | // "args": ["/c"] 6 | "args": ["/c", "chcp 65001 >nul &"] 7 | }, 8 | "linux": { 9 | "command": "sh", 10 | "args": ["-c"] 11 | }, 12 | "isShellCommand": true, 13 | "showOutput": "silent", 14 | "tasks": [ 15 | { 16 | "taskName": "Testing project", 17 | "args": [ 18 | "1testrunner", 19 | "-runall", 20 | "${workspaceRoot}/tests" 21 | ], 22 | "echoCommand": true, 23 | "showOutput": "always", 24 | "suppressTaskName": true, 25 | // "isBuildCommand": false, 26 | "isTestCommand": false, 27 | "problemMatcher": { 28 | "fileLocation": "absolute", 29 | "pattern": { 30 | "regexp": "{Модуль\\s+(.+)\\s\\/\\s.*:\\s+(\\d+)\\s+\\/\\s+([^{]*)", 31 | "file": 1, 32 | "location": 2, 33 | "message": 3 34 | } 35 | } 36 | }, 37 | { 38 | "taskName": "Testing current test-file", 39 | "args": [ 40 | "1testrunner", 41 | "-run", 42 | "${file}" 43 | ], 44 | "echoCommand": true, 45 | "showOutput": "always", 46 | "suppressTaskName": true, 47 | "isBuildCommand": false, 48 | "isTestCommand": true, 49 | "problemMatcher": { 50 | "fileLocation": "absolute", 51 | "pattern": { 52 | "regexp": "{Модуль\\s+(.+)\\s\\/\\s.*:\\s+(\\d+)\\s+\\/\\s+([^{]*)", 53 | "file": 1, 54 | "location": 2, 55 | "message": 3 56 | } 57 | } 58 | }, 59 | { 60 | "taskName": "Exec all features", 61 | "args": [ 62 | "1bdd", 63 | "${workspaceRoot}/features", 64 | "-out", 65 | "${workspaceRoot}/exec.log" 66 | ], 67 | "echoCommand": true, 68 | "showOutput": "always", 69 | "suppressTaskName": true, 70 | "isBuildCommand": true, 71 | "isTestCommand": false, 72 | "problemMatcher": { 73 | "fileLocation": "absolute", 74 | "pattern": { 75 | "regexp": "{Модуль\\s+(.+)\\s\\/\\s.*:\\s+(\\d+)\\s+\\/\\s+([^{]*)", 76 | "file": 1, 77 | "location": 2, 78 | "message": 3 79 | } 80 | } 81 | }, 82 | { 83 | "taskName": "Exec feature", 84 | "args": [ 85 | "1bdd", 86 | "${file}", 87 | "-fail-fast", 88 | "-out", 89 | "${workspaceRoot}/exec.log" 90 | ], 91 | "echoCommand": true, 92 | "showOutput": "always", 93 | "suppressTaskName": true, 94 | "isBuildCommand": false, 95 | "isTestCommand": true, 96 | "problemMatcher": { 97 | "fileLocation": "absolute", 98 | "pattern": [ 99 | { 100 | "regexp": "{Модуль\\s+(.+)\\s\\/\\s.*:\\s+(\\d+)\\s+\\/\\s+([^{]*)", 101 | "file": 1, 102 | "location": 2, 103 | "message": 3 104 | } 105 | ] 106 | } 107 | }, 108 | { 109 | "taskName": "Exec feature for current step def", 110 | "args": [ 111 | "1bdd", 112 | "${fileDirname}/../${fileBasenameNoExtension}.feature", 113 | "-fail-fast", 114 | "-out", 115 | "${workspaceRoot}/exec.log" 116 | ], 117 | "echoCommand": true, 118 | "showOutput": "always", 119 | "suppressTaskName": true, 120 | "isBuildCommand": false, 121 | "isTestCommand": true, 122 | "problemMatcher": { 123 | "fileLocation": "absolute", 124 | "pattern": [ 125 | { 126 | "regexp": "{Модуль\\s+(.+)\\s\\/\\s.*:\\s+(\\d+)\\s+\\/\\s+([^{]*)", 127 | "file": 1, 128 | "location": 2, 129 | "message": 3 130 | } 131 | ] 132 | } 133 | }, 134 | { 135 | "taskName": "Exec feature + debug", 136 | "args": [ 137 | "1bdd", 138 | "${file}", 139 | "-fail-fast", 140 | "-verbose", 141 | "on", 142 | "-out", 143 | "${workspaceRoot}/exec.log" 144 | ], 145 | "echoCommand": true, 146 | "showOutput": "always", 147 | "suppressTaskName": true, 148 | // "isBuildCommand": false, 149 | "isTestCommand": false, 150 | "problemMatcher": { 151 | "fileLocation": "absolute", 152 | "pattern": { 153 | "regexp": "{Модуль\\s+(.+)\\s\\/\\s.*:\\s+(\\d+)\\s+\\/\\s+([^{]*)", 154 | "file": 1, 155 | "location": 2, 156 | "message": 3 157 | } 158 | } 159 | }, 160 | { 161 | "taskName": "Generate feature steps", 162 | "args": [ 163 | "1bdd", 164 | "gen", 165 | "${file}", 166 | "-out", 167 | "${workspaceRoot}/exec.log" 168 | ], 169 | "echoCommand": true, 170 | "showOutput": "always", 171 | "suppressTaskName": true, 172 | "isBuildCommand": false, 173 | "isTestCommand": false, 174 | "problemMatcher": { 175 | "fileLocation": "absolute", 176 | "pattern": { 177 | "regexp": "{Модуль\\s+(.+)\\s\\/\\s.*:\\s+(\\d+)\\s+\\/\\s+([^{]*)", 178 | "file": 1, 179 | "location": 2, 180 | "message": 3 181 | } 182 | } 183 | }, 184 | { 185 | "taskName": "OneScript: compile", 186 | "args": [ 187 | "oscript", 188 | "-encoding=utf-8", 189 | "-compile", 190 | "${file}" 191 | ], 192 | "echoCommand": true, 193 | "showOutput": "always", 194 | "suppressTaskName": true, 195 | "isBuildCommand": false 196 | }, 197 | { 198 | "taskName": "OneScript: check", 199 | "args": [ 200 | "oscript", 201 | "-encoding=utf-8", 202 | "-check", 203 | "${file}" 204 | ], 205 | "echoCommand": true, 206 | "showOutput": "always", 207 | "suppressTaskName": true, 208 | "isBuildCommand": false 209 | }, 210 | { 211 | "taskName": "OneScript: make", 212 | "args": [ 213 | "oscript", 214 | "-encoding=utf-8", 215 | "-make", 216 | "${file}", 217 | "${fileBasename}.exe" 218 | ], 219 | "echoCommand": true, 220 | "showOutput": "always", 221 | "suppressTaskName": true, 222 | "isBuildCommand": false 223 | }, 224 | { 225 | "taskName": "OneScript: run", 226 | "args": [ 227 | "oscript", 228 | "-encoding=utf-8", 229 | "${file}" 230 | ], 231 | "echoCommand": true, 232 | "showOutput": "always", 233 | "suppressTaskName": true, 234 | "isBuildCommand": true, 235 | "problemMatcher": { 236 | "fileLocation": "absolute", 237 | "pattern": { 238 | "regexp": "^{Модуль\\s+(.*)\\s\\/\\s.*:\\s+(\\d+)\\s+\\/\\s+(.*)}$", 239 | "file": 1, 240 | "location": 2, 241 | "message": 3 242 | } 243 | } 244 | } 245 | ] 246 | } -------------------------------------------------------------------------------- /tests/bdd-assertions-tests.os: -------------------------------------------------------------------------------- 1 | &Тест 2 | Процедура ТестДолжен_Проверить_ЭтоИстина() Экспорт 3 | Ожидаем.Что(5 > 1).ЭтоИстина(); 4 | Ожидаем.Что(Истина).ЭтоИстина(); 5 | КонецПроцедуры 6 | 7 | &Тест 8 | Процедура ТестДолжен_Проверить_Отрицание_ЭтоИстина() Экспорт 9 | Ожидаем.Что(5 < 1).Не_().ЭтоИстина(); 10 | Ожидаем.Что(Ложь).Не_().ЭтоИстина(); 11 | КонецПроцедуры 12 | 13 | &Тест 14 | Процедура ТестДолжен_Проверить_ЭтоЛожь() Экспорт 15 | Ожидаем.Что(5 < 1).ЭтоЛожь(); 16 | Ожидаем.Что(Ложь).ЭтоЛожь(); 17 | КонецПроцедуры 18 | 19 | &Тест 20 | Процедура ТестДолжен_Проверить_Отрицание_ЭтоЛожь() Экспорт 21 | Ожидаем.Что(5 > 1).Не_().ЭтоЛожь(); 22 | Ожидаем.Что(Истина).Не_().ЭтоЛожь(); 23 | КонецПроцедуры 24 | 25 | &Тест 26 | Процедура ТестДолжен_Проверить_Равно() Экспорт 27 | Ожидаем.Что(5).Равно(5); 28 | Ожидаем.Что("некая строка").Равно("некая строка"); 29 | КонецПроцедуры 30 | 31 | &Тест 32 | Процедура ТестДолжен_Проверить_Отрицание_Равно() Экспорт 33 | Ожидаем.Что(5).Не_().Равно(7); 34 | КонецПроцедуры 35 | 36 | &Тест 37 | Процедура ТестДолжен_Проверить_Больше() Экспорт 38 | Ожидаем.Что(4).Больше(2); 39 | КонецПроцедуры 40 | 41 | &Тест 42 | Процедура ТестДолжен_Проверить_Отрицание_Больше() Экспорт 43 | Ожидаем.Что(7).Не_().Больше(11); 44 | Ожидаем.Что(7).Не_().Больше(7); 45 | КонецПроцедуры 46 | 47 | &Тест 48 | Процедура ТестДолжен_Проверить_БольшеИлиРавно_И_Минимум() Экспорт 49 | НекоеЧисло = 9; 50 | Ожидаем.Что(НекоеЧисло).БольшеИлиРавно(5); 51 | Ожидаем.Что(НекоеЧисло).БольшеИлиРавно(9); 52 | 53 | Ожидаем.Что(НекоеЧисло).Минимум(1); 54 | Ожидаем.Что(НекоеЧисло).Минимум(9); 55 | КонецПроцедуры 56 | 57 | &Тест 58 | Процедура ТестДолжен_Проверить_Отрицание_БольшеИлиРавно_И_Минимум() Экспорт 59 | НекоеЧисло = 15; 60 | Ожидаем.Что(НекоеЧисло).Не_().БольшеИлиРавно(20); 61 | Ожидаем.Что(НекоеЧисло).Не_().Минимум(16); 62 | КонецПроцедуры 63 | 64 | &Тест 65 | Процедура ТестДолжен_Проверить_МеньшеИлиРавно_И_Максимум() Экспорт 66 | НекоеЧисло = 30; 67 | Ожидаем.Что(НекоеЧисло).МеньшеИлиРавно(32); 68 | Ожидаем.Что(НекоеЧисло).МеньшеИлиРавно(30); 69 | 70 | Ожидаем.Что(НекоеЧисло).Максимум(37); 71 | Ожидаем.Что(НекоеЧисло).Максимум(30); 72 | КонецПроцедуры 73 | 74 | &Тест 75 | Процедура ТестДолжен_Проверить_Отрицание_МеньшеИлиРавно_И_Максимум() Экспорт 76 | НекоеЧисло = 17; 77 | Ожидаем.Что(НекоеЧисло).Не_().МеньшеИлиРавно(16); 78 | Ожидаем.Что(НекоеЧисло).Не_().Максимум(11); 79 | КонецПроцедуры 80 | 81 | &Тест 82 | Процедура ТестДолжен_Проверить_Меньше() Экспорт 83 | Ожидаем.Что(5).Меньше(10); 84 | КонецПроцедуры 85 | 86 | &Тест 87 | Процедура ТестДолжен_Проверить_Отрицание_Меньше() Экспорт 88 | Ожидаем.Что(5).Не_().Меньше(3); 89 | Ожидаем.Что(5).Не_().Меньше(5); 90 | КонецПроцедуры 91 | 92 | &Тест 93 | Процедура ТестДолжен_Проверить_Заполнено() Экспорт 94 | Ожидаем.Что(7).Заполнено(); 95 | Ожидаем.Что("!!!").Заполнено(); 96 | КонецПроцедуры 97 | 98 | &Тест 99 | Процедура ТестДолжен_Проверить_Отрицание_Заполнено() Экспорт 100 | Ожидаем.Что(0).Не_().Заполнено(); 101 | Ожидаем.Что("").Не_().Заполнено(); 102 | Ожидаем.Что(Новый Массив).Не_().Заполнено(); 103 | КонецПроцедуры 104 | 105 | &Тест 106 | Процедура ТестДолжен_Проверить_Существует() Экспорт 107 | Ожидаем.Что(0).Существует(); 108 | Ожидаем.Что("").Существует(); 109 | Ожидаем.Что(Новый Массив).Существует(); 110 | КонецПроцедуры 111 | 112 | &Тест 113 | Процедура ТестДолжен_Проверить_Отрицание_Существует() Экспорт 114 | Ожидаем.Что(Неопределено).Не_().Существует(); 115 | Ожидаем.Что(Null).Не_().Существует(); 116 | КонецПроцедуры 117 | 118 | &Тест 119 | Процедура ТестДолжен_Проверить_ЭтоНеопределено() Экспорт 120 | Перем Переменная; 121 | Ожидаем.Что(Переменная).ЭтоНеопределено(); 122 | КонецПроцедуры 123 | 124 | &Тест 125 | Процедура ТестДолжен_Проверить_Отрицание_ЭтоНеопределено() Экспорт 126 | Ожидаем.Что(0).Не_().ЭтоНеопределено(); 127 | Ожидаем.Что(Null).Не_().ЭтоНеопределено(); 128 | КонецПроцедуры 129 | 130 | &Тест 131 | Процедура ТестДолжен_Проверить_ЭтоNull() Экспорт 132 | Ссылка = Null; 133 | Ожидаем.Что(Ссылка).ЭтоNull(); 134 | КонецПроцедуры 135 | 136 | &Тест 137 | Процедура ТестДолжен_Проверить_Отрицание_ЭтоNull() Экспорт 138 | Ожидаем.Что("").Не_().ЭтоNull(); 139 | Ожидаем.Что(Неопределено).Не_().ЭтоNull(); 140 | КонецПроцедуры 141 | 142 | &Тест 143 | Процедура ТестДолжен_Проверить_ИмеетТип() Экспорт 144 | Ожидаем.Что(Новый Массив).ИмеетТип("Массив"); 145 | Ожидаем.Что(5).ИмеетТип(Тип("Число")); 146 | КонецПроцедуры 147 | 148 | &Тест 149 | Процедура ТестДолжен_Проверить_Отрицание_ИмеетТип() Экспорт 150 | Ожидаем.Что("").Не_().ИмеетТип("Массив"); 151 | Ожидаем.Что(5).Не_().ИмеетТип(Тип("Дата")); 152 | КонецПроцедуры 153 | 154 | &Тест 155 | Процедура ТестДолжен_Проверить_Между() Экспорт 156 | Ожидаем.Что(5).Между(3, 7); 157 | Ожидаем.Что(3).Между(3, 7); 158 | Ожидаем.Что(7).Между(3, 7); 159 | КонецПроцедуры 160 | 161 | &Тест 162 | Процедура ТестДолжен_Проверить_Отрицание_Между() Экспорт 163 | Ожидаем.Что(1).Не_().Между(3, 7); 164 | КонецПроцедуры 165 | 166 | &Тест 167 | Процедура ТестДолжен_Проверить_Содержит() Экспорт 168 | Ожидаем.Что("Некая строка", "Строка").Содержит("ока"); 169 | 170 | НекийМассив = Новый Массив; 171 | НекийМассив.Добавить(1); 172 | НекийМассив.Добавить(2); 173 | Ожидаем.Что(НекийМассив, "НекийМассив").Содержит(2); 174 | 175 | НекаяСтруктура = Новый Структура("Ключ1, Ключ2", "Значение1", "Значение2"); 176 | Ожидаем.Что(НекаяСтруктура, "НекаяСтруктура").Содержит("Значение1"); 177 | 178 | НекоеСоответствие = Новый Соответствие; 179 | НекоеСоответствие.Вставить(1, НекийМассив); 180 | НекоеСоответствие.Вставить(2, НекаяСтруктура); 181 | Ожидаем.Что(НекоеСоответствие, "НекоеСоответствие").Содержит(НекийМассив); 182 | 183 | НекийСписокЗначений = Новый СписокЗначений; 184 | НекийСписокЗначений.Добавить("знач1"); 185 | НекийСписокЗначений.Добавить("знач2"); 186 | Ожидаем.Что(НекийСписокЗначений, "НекийСписокЗначений").Содержит("знач1"); 187 | КонецПроцедуры 188 | 189 | &Тест 190 | Процедура ТестДолжен_Проверить_Содержит_ДляМногострочныхСтрок() Экспорт 191 | Строка = " 192 | | 193 | | 194 | | 195 | | 196 | | 197 | |"; 198 | 199 | ЧтоИщем = " 200 | | 201 | | 202 | | 203 | | 204 | |"; 205 | 206 | Ожидаем.Что(Строка, "Строка").Содержит(ЧтоИщем); 207 | КонецПроцедуры 208 | 209 | &Тест 210 | Процедура ТестДолжен_Проверить_Отрицание_Содержит() Экспорт 211 | Ожидаем.Что("Некая строка").Не_().Содержит("!!!"); 212 | 213 | НекийМассив = Новый Массив; 214 | НекийМассив.Добавить(1); 215 | НекийМассив.Добавить(2); 216 | Ожидаем.Что(НекийМассив).Не_().Содержит(7); 217 | КонецПроцедуры 218 | 219 | &Тест 220 | Процедура ТестДолжен_Проверить_ИмеетДлину() Экспорт 221 | Ожидаем.Что("Некая строка", "Строка").ИмеетДлину(12); 222 | 223 | НекийМассив = Новый Массив; 224 | НекийМассив.Добавить(1); 225 | НекийМассив.Добавить(2); 226 | Ожидаем.Что(НекийМассив, "НекийМассив").ИмеетДлину(2); 227 | 228 | НекаяСтруктура = Новый Структура("Ключ1, Ключ2, Ключ3", "Значение1", "Значение2"); 229 | Ожидаем.Что(НекаяСтруктура, "НекаяСтруктура").ИмеетДлину(3); 230 | 231 | НекоеСоответствие = Новый Соответствие; 232 | НекоеСоответствие.Вставить(1, НекийМассив); 233 | НекоеСоответствие.Вставить(2, НекаяСтруктура); 234 | Ожидаем.Что(НекоеСоответствие, "НекоеСоответствие").ИмеетДлину(2); 235 | 236 | НекийСписокЗначений = Новый СписокЗначений; 237 | НекийСписокЗначений.ЗагрузитьЗначения(НекийМассив); 238 | НекийСписокЗначений.Добавить("знач1"); 239 | НекийСписокЗначений.Добавить("знач2"); 240 | Ожидаем.Что(НекийСписокЗначений, "НекийСписокЗначений").ИмеетДлину(4); 241 | КонецПроцедуры 242 | 243 | &Тест 244 | Процедура ТестДолжен_Проверить_Отрицание_ИмеетДлину() Экспорт 245 | Ожидаем.Что("Некая строка", "Строка").Не_().ИмеетДлину(1); 246 | 247 | НекаяСтруктура = Новый Структура("Ключ1, Ключ2, Ключ3", "Значение1", "Значение2"); 248 | Ожидаем.Что(НекаяСтруктура, "НекаяСтруктура").Не_().ИмеетДлину(4); 249 | КонецПроцедуры 250 | 251 | &Тест 252 | Процедура ТестДолжен_Проверить_КомпозитныеУтверждения() Экспорт 253 | Ожидаем.Что("Некая строка") 254 | .Существует() 255 | .ИмеетТип("Строка") 256 | .ИмеетДлину(12) 257 | .Содержит("стр"); 258 | КонецПроцедуры 259 | 260 | &Тест 261 | Процедура ТестДолжен_Проверить_КомпозитныеУтверждения_ВПеремешкуС_Отрицаниями() Экспорт 262 | Ожидаем.Что("Некая строка") 263 | .Существует() 264 | .Не_().ИмеетТип("Число") 265 | .ИмеетДлину(12) 266 | .Не_().Содержит("!!!"); 267 | КонецПроцедуры 268 | 269 | &Тест 270 | Процедура ТестДолжен_Проверить_ЧтоВыбрасываетсяИсключение() Экспорт 271 | Контекст = Новый Структура; 272 | 273 | Ожидаем.Что(Контекст).Метод("Вставить").ВыбрасываетИсключение("Недостаточно фактических параметров"); 274 | 275 | Массив = Новый Массив; 276 | Массив.Добавить("Ключ"); 277 | Массив.Добавить("Значение"); 278 | 279 | Ожидаем.Что(Контекст).Метод("Вставить", Массив).Не_().ВыбрасываетИсключение("Недостаточно фактических параметров"); 280 | КонецПроцедуры 281 | 282 | &Тест 283 | Процедура ТестДолжен_Проверить_ЧтоНеВыбрасываетсяИсключение() Экспорт 284 | 285 | Контекст = Новый Структура; 286 | ИсключениеВозникло = Ложь; 287 | 288 | Попытка 289 | 290 | Ожидаем.Что(Контекст) 291 | .Метод("Вставить") 292 | .Не_() 293 | .ВыбрасываетИсключение(); 294 | 295 | Исключение 296 | ИсключениеВозникло = Истина; 297 | ТекстОшибки = ОписаниеОшибки(); 298 | КонецПопытки; 299 | 300 | Ожидаем.Что(ИсключениеВозникло) 301 | .ЭтоИстина(); 302 | 303 | Ожидаем.Что(ТекстОшибки) 304 | .Содержит("Ожидали, что Вставить НЕ ВЫБРОСИТ ИСКЛЮЧЕНИЕ") 305 | .Содержит("Недостаточно фактических параметров"); 306 | 307 | КонецПроцедуры 308 | -------------------------------------------------------------------------------- /src/Модули/Утверждения.os: -------------------------------------------------------------------------------- 1 | Процедура Проверить(Условие, ДопСообщениеОшибки = "") Экспорт 2 | 3 | Если Условие Тогда 4 | Возврат; 5 | КонецЕсли; 6 | 7 | СообщениеОшибки = СтрШаблон( 8 | "Переданный параметр (%1) не является Истиной, а хотели, чтобы являлся. %2", 9 | Формат(Условие, "БЛ=ложь; БИ=истина"), 10 | ФорматДСО(ДопСообщениеОшибки) 11 | ); 12 | 13 | ВызватьОшибкуУтверждения(СообщениеОшибки); 14 | 15 | КонецПроцедуры 16 | 17 | Процедура ПроверитьИстину(Условие, ДопСообщениеОшибки = "") Экспорт 18 | Проверить(Условие, ДопСообщениеОшибки); 19 | КонецПроцедуры 20 | 21 | Процедура ПроверитьЛожь(Условие, ДопСообщениеОшибки = "") Экспорт 22 | 23 | Если Не Условие Тогда 24 | Возврат; 25 | КонецЕсли; 26 | 27 | СообщениеОшибки = СтрШаблон( 28 | "Переданный параметр (%1) не является Ложью, а хотели, чтобы являлся. %2", 29 | Формат(Условие, "БЛ=ложь; БИ=истина"), 30 | ФорматДСО(ДопСообщениеОшибки) 31 | ); 32 | 33 | ВызватьОшибкуУтверждения(СообщениеОшибки); 34 | 35 | КонецПроцедуры 36 | 37 | Процедура ПроверитьДату(Дата, Период, ДопСообщениеОшибки = "") Экспорт 38 | 39 | Если Дата > Период.ДатаНачала И Дата < Период.ДатаОкончания Тогда 40 | Возврат; 41 | КонецЕсли; 42 | 43 | СообщениеОшибки = СтрШаблон( 44 | "Переданный параметр (%1) не входит в период %2, а хотели, чтобы входил. %3", 45 | Формат(Дата, "ДФ='dd.MM.yyyy HH:mm:ss'"), 46 | ПредставлениеПериода(Период.ДатаНачала, Период.ДатаОкончания, "ФП = Истина") 47 | ); 48 | 49 | ВызватьОшибкуУтверждения(СообщениеОшибки); 50 | 51 | КонецПроцедуры 52 | 53 | Процедура ПроверитьРавенствоДатСТочностью2Секунды(Дата, Дата2, ДопСообщениеОшибки = "") Экспорт 54 | 55 | Если Дата > Дата2 - 2 И Дата < Дата2 + 2 Тогда 56 | Возврат; 57 | КонецЕсли; 58 | 59 | СообщениеОшибки = СтрШаблон( 60 | "Переданная дата (%1) не равна дате (%2) с точностью до 2-х секунд, а хотели, чтобы они равнялись. %3", 61 | Формат(Дата, "ДФ='dd.MM.yyyy HH:mm:ss'"), 62 | Формат(Дата2, "ДФ='dd.MM.yyyy HH:mm:ss'"), 63 | ФорматДСО(ДопСообщениеОшибки) 64 | ); 65 | 66 | ВызватьОшибкуУтверждения(СообщениеОшибки); 67 | 68 | КонецПроцедуры 69 | 70 | Процедура ПроверитьРавенство(ПервоеЗначение, ВтороеЗначение, ДопСообщениеОшибки = "") Экспорт 71 | Если ПервоеЗначение <> ВтороеЗначение Тогда 72 | СообщениеОшибки = "Сравниваемые значения ("+ПервоеЗначение+"; "+ВтороеЗначение+") не равны, а хотели, чтобы были равны." + ФорматДСО(ДопСообщениеОшибки); 73 | ВызватьОшибкуУтверждения(СообщениеОшибки); 74 | КонецЕсли; 75 | КонецПроцедуры 76 | 77 | Процедура ПроверитьНеРавенство(ПервоеЗначение, ВтороеЗначение, ДопСообщениеОшибки = "") Экспорт 78 | 79 | Если ПервоеЗначение <> ВтороеЗначение Тогда 80 | Возврат; 81 | КонецЕсли; 82 | 83 | СообщениеОшибки = СтрШаблон( 84 | "Сравниваемые значения (%1; %2) равны, а хотели, чтобы были не равны. %3", 85 | ПервоеЗначение, 86 | ВтороеЗначение, 87 | ФорматДСО(ДопСообщениеОшибки) 88 | ); 89 | 90 | ВызватьОшибкуУтверждения(СообщениеОшибки); 91 | 92 | КонецПроцедуры 93 | 94 | Процедура ПроверитьБольше(Больше, Меньше, ДопСообщениеОшибки = "") Экспорт 95 | 96 | Если Больше > Меньше Тогда 97 | Возврат; 98 | КонецЕсли; 99 | 100 | СообщениеОшибки = СтрШаблон( 101 | "Первый параметр (%1) меньше или равен второму (%2) а хотели, чтобы был больше. %3", 102 | Больше, 103 | Меньше, 104 | ФорматДСО(ДопСообщениеОшибки) 105 | ); 106 | 107 | ВызватьОшибкуУтверждения(СообщениеОшибки); 108 | 109 | КонецПроцедуры 110 | 111 | Процедура ПроверитьБольшеИлиРавно(Больше, Меньше, ДопСообщениеОшибки = "") Экспорт 112 | 113 | Если Больше >= Меньше Тогда 114 | Возврат; 115 | КонецЕсли; 116 | 117 | СообщениеОшибки = СтрШаблон( 118 | "Первый параметр (%1) меньше второго (%2) а хотели, чтобы был больше или равен. %3", 119 | Больше, 120 | Меньше, 121 | ФорматДСО(ДопСообщениеОшибки) 122 | ); 123 | 124 | ВызватьОшибкуУтверждения(СообщениеОшибки); 125 | 126 | КонецПроцедуры 127 | 128 | Процедура ПроверитьМеньше(Меньше, Больше, ДопСообщениеОшибки = "") Экспорт 129 | 130 | Если Больше > Меньше Тогда 131 | Возврат; 132 | КонецЕсли; 133 | 134 | СообщениеОшибки = СтрШаблон( 135 | "Первый параметр (%1) больше или равен второму (%2) а хотели, чтобы был меньше. %3", 136 | Меньше, 137 | Больше, 138 | ФорматДСО(ДопСообщениеОшибки) 139 | ); 140 | 141 | ВызватьОшибкуУтверждения(СообщениеОшибки); 142 | 143 | КонецПроцедуры 144 | 145 | Процедура ПроверитьМеньшеИлиРавно(Меньше, Больше, ДопСообщениеОшибки = "") Экспорт 146 | 147 | Если Больше >= Меньше Тогда 148 | Возврат; 149 | КонецЕсли; 150 | 151 | СообщениеОшибки = СтрШаблон( 152 | "Первый параметр (%1) больше второго (%2) а хотели, чтобы был больше или равен. %3", 153 | Меньше, 154 | Больше, 155 | ФорматДСО(ДопСообщениеОшибки) 156 | ); 157 | 158 | ВызватьОшибкуУтверждения(СообщениеОшибки); 159 | 160 | КонецПроцедуры 161 | 162 | // проверка идет через ЗначениеЗаполнено, но мутабельные значение всегда считаем заполненными 163 | Процедура ПроверитьЗаполненность(ПроверяемоеЗначение, ДопСообщениеОшибки = "") Экспорт 164 | 165 | Попытка 166 | Заполнено = ЗначениеЗаполнено(ПроверяемоеЗначение); 167 | Исключение 168 | Заполнено = Истина; 169 | КонецПопытки; 170 | 171 | Если Заполнено Тогда 172 | Возврат; 173 | КонецЕсли; 174 | 175 | ВызватьОшибкуУтверждения( 176 | СтрШаблон( 177 | "Значение (%1) не заполнено, а ожидалась заполненность %2", 178 | ПроверяемоеЗначение, 179 | ФорматДСО(ДопСообщениеОшибки) 180 | ) 181 | ); 182 | 183 | КонецПроцедуры 184 | 185 | Процедура ПроверитьНеЗаполненность(ПроверяемоеЗначение, ДопСообщениеОшибки = "") Экспорт 186 | 187 | СообщениеОшибки = СтрШаблон( 188 | "Значение (%1) заполнено, а ожидалась незаполненность", 189 | ПроверяемоеЗначение, 190 | ФорматДСО(ДопСообщениеОшибки) 191 | ); 192 | 193 | Попытка 194 | Заполнено = ЗначениеЗаполнено(ПроверяемоеЗначение); 195 | Исключение 196 | Заполнено = Истина; 197 | КонецПопытки; 198 | 199 | Если Заполнено Тогда 200 | ВызватьОшибкуУтверждения(СообщениеОшибки); 201 | КонецЕсли; 202 | 203 | КонецПроцедуры 204 | 205 | Процедура ПроверитьТип(Значение, ТипИлиИмяТипа, ДопСообщениеОшибки = "") Экспорт 206 | 207 | Если ТипЗнч(ТипИлиИмяТипа) = Тип("Строка") Тогда 208 | ОжидаемыйТип = Тип(ТипИлиИмяТипа); 209 | ИначеЕсли ТипЗнч(ТипИлиИмяТипа) = Тип("Тип") Тогда 210 | ОжидаемыйТип = ТипИлиИмяТипа; 211 | Иначе 212 | 213 | ТекстИсключения = СтрШаблон( 214 | "ПроверитьТип: Тип значения параметра ТипИлиИмяТипа должен быть <Тип> или <Строка>, а получили <%1>. %2", 215 | ТипЗнч(ТипИлиИмяТипа), 216 | ФорматДСО(ДопСообщениеОшибки) 217 | ); 218 | 219 | ВызватьОшибкуУтверждения(ТекстИсключения); 220 | 221 | КонецЕсли; 222 | 223 | Если ТипЗнч(Значение) = ОжидаемыйТип Тогда 224 | Возврат; 225 | КонецЕсли; 226 | 227 | ОшибкаПроверки = СтрШаблон( 228 | "Типом значения <%1> является <%2>, а ожидался тип <%3>. %4", 229 | Значение, 230 | ТипЗнч(Значение), 231 | ТипИлиИмяТипа, 232 | ФорматДСО(ДопСообщениеОшибки) 233 | ); 234 | 235 | ВызватьОшибкуУтверждения(ОшибкаПроверки); 236 | 237 | КонецПроцедуры 238 | 239 | Процедура ПроверитьЧтоВСтрокеСодержатсяТолькоЦифры(Знач ИсходнаяСтрока, ДопСообщениеОшибки = "") Экспорт 240 | 241 | // Порт из testrunner в составе oscript-engine 242 | 243 | СообщениеОшибки = СтрШаблон( 244 | "Строка (%1) содержит не только цифры, а ожидалась обратное %2", 245 | ИсходнаяСтрока, 246 | ФорматДСО(ДопСообщениеОшибки) 247 | ); 248 | 249 | ТолькоЦифры = Ложь; 250 | ДлинаСтроки = СтрДлина(ИсходнаяСтрока); 251 | 252 | Для Сч = 1 По ДлинаСтроки Цикл 253 | 254 | ТекущийСимвол = КодСимвола(Сред(ИсходнаяСтрока, Сч, 1)); 255 | 256 | Если 48 <= ТекущийСимвол И ТекущийСимвол <= 57 Тогда 257 | ТолькоЦифры = Истина; 258 | Иначе 259 | ТолькоЦифры = Ложь; 260 | Прервать; 261 | КонецЕсли; 262 | 263 | КонецЦикла; 264 | 265 | Если НЕ ТолькоЦифры Тогда 266 | ВызватьОшибкуУтверждения(СообщениеОшибки); 267 | КонецЕсли; 268 | 269 | КонецПроцедуры 270 | 271 | Процедура ПроверитьВхождение(Строка, ПодстрокаПоиска, ДопСообщениеОшибки = "") Экспорт 272 | 273 | Если СтрНайти(Строка, ПодстрокаПоиска) <> 0 Тогда 274 | Возврат; 275 | КонецЕсли; 276 | 277 | СообщениеОшибки = СтрШаблон( 278 | "Искали в <%1> подстроку <%2>, но не нашли. %3", 279 | Строка, 280 | ПодстрокаПоиска, 281 | ФорматДСО(ДопСообщениеОшибки) 282 | ); 283 | 284 | ВызватьОшибкуУтверждения(СообщениеОшибки); 285 | 286 | КонецПроцедуры 287 | 288 | Процедура ПроверитьКодСОшибкой( Код, Ошибка, ДопСообщениеОшибки = "" ) Экспорт 289 | 290 | ИнформацияОбОшибке = Неопределено; 291 | 292 | Попытка 293 | Сценарий = ЗагрузитьСценарийИзСтроки(Код); 294 | СообщениеОшибки = СтрШаблон("Ожидали ошибку '%1', но ее не было", Ошибка); 295 | Исключение 296 | 297 | ИнформацияОбОшибке = ИнформацияОбОшибке(); 298 | ОписаниеОшибки = ИнформацияОбОшибке.Описание; 299 | 300 | Если СтрНайти(ОписаниеОшибки, Ошибка ) <> 0 Тогда 301 | Возврат; 302 | КонецЕсли; 303 | 304 | СообщениеОшибки = СтрШаблон("Ожидали ошибку '%1', а была ошибка %2", Ошибка, ОписаниеОшибки); 305 | 306 | КонецПопытки; 307 | 308 | ВызватьОшибкуУтверждения(СтрШаблон("%1 %2", СообщениеОшибки, ФорматДСО(ДопСообщениеОшибки)), ИнформацияОбОшибке); 309 | 310 | КонецПроцедуры 311 | 312 | // Проверяет существование метода у объекта 313 | // 314 | // Выбрасывает исключение, если метод отсутствует 315 | // 316 | // Параметры: 317 | // Объект - Любой - Объект, у которого требуется проверить наличие метода 318 | // 319 | // ИмяМетода - Строка - Имя метода, наличие которого требуется проверить 320 | // 321 | // ДопСообщениеОшибки - Строка - Необязательный. Дополнительное пояснение проверки. 322 | // Включается в текст исключения в случае, если проверка не была пройдена 323 | Процедура ПроверитьМетодСуществует(Знач Объект, Знач ИмяМетода, Знач ДопСообщениеОшибки = "") Экспорт 324 | 325 | Если Новый Рефлектор.МетодСуществует(Объект, ИмяМетода) Тогда 326 | Возврат 327 | КонецЕсли; 328 | 329 | ВызватьОшибкуУтверждения( 330 | СтрШаблон( 331 | "Ожидали, что объект имеет метод с именем %1. %2", 332 | ИмяМетода, 333 | ФорматДСО(ДопСообщениеОшибки) 334 | ) 335 | ); 336 | 337 | КонецПроцедуры 338 | 339 | Функция ФорматДСО(ДопСообщениеОшибки) 340 | 341 | Если ДопСообщениеОшибки = "" Тогда 342 | Возврат ""; 343 | КонецЕсли; 344 | 345 | Возврат Символы.ПС + ДопСообщениеОшибки; 346 | 347 | КонецФункции 348 | 349 | Функция ПредставлениеПериода(ДатаНачала, ДатаОкончания, ФорматнаяСтрока = Неопределено) 350 | Возврат СтрШаблон("с %1 по %2", ДатаНачала, ДатаОкончания); 351 | КонецФункции 352 | 353 | Процедура ВызватьОшибкуУтверждения(ТекстИсключения, Причина = Неопределено) 354 | 355 | Контекст = Новый ИсключениеОшибкаУтверждения(); 356 | 357 | Если Число(Лев(Новый СистемнаяИнформация().Версия, 1)) >= 2 Тогда 358 | ВызватьИсключение Новый ИнформацияОбОшибке(ТекстИсключения, Контекст, Причина); 359 | Иначе 360 | ВызватьИсключение Новый ИнформацияОбОшибке(ТекстИсключения, Контекст); 361 | КонецЕсли; 362 | 363 | КонецПроцедуры 364 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Утверждения 2 | 3 | Добавляет в скрипт функционал "Утверждений" (assertions). Возможны 2 стиля использования: 4 | 5 | * **Модуль "Утверждения"** - утверждения в стиле фреймворка xUnitFor1C 6 | * **Свойство глобального контекста "Ожидаем"** - [fluent-API утверждений в стиле BDD](http://habrahabr.ru/post/260013/) 7 | 8 | ## Краткий пример 9 | 10 | ```bsl 11 | МояПеременная = ВычислитьЧтоТоТам(); 12 | 13 | // xUnit style 14 | Утверждения.ПроверитьРавенство(1, МояПеременная, "Моя переменная должна быть строго равна 1"); 15 | 16 | // BDD style 17 | Ожидаем.Что(МояПеременная).Равно(1); 18 | ``` 19 | 20 | ## Модуль "Ожидаем" 21 | 22 | BDD стиль предоставляет fluent API для создания более читаемых утверждений. 23 | 24 | ### Базовый синтаксис 25 | 26 | ```bsl 27 | Ожидаем.Что(ПроверяемоеЗначение).МетодПроверки(ПараметрыПроверки); 28 | ``` 29 | 30 | ### Отрицание 31 | 32 | #### `Не_()` / `ЭтоНе()` 33 | 34 | Инвертирует результат следующей проверки. 35 | 36 | ```bsl 37 | Ожидаем.Что(Значение).Не_().Равно(0); 38 | Ожидаем.Что(Строка).ЭтоНе().Заполнено(); 39 | ``` 40 | 41 | ### Логические проверки 42 | 43 | #### `ЭтоИстина()` / `ЕстьИстина()` 44 | 45 | Проверяет, что значение равно `Истина`. 46 | 47 | ```bsl 48 | Ожидаем.Что(УсловиеВыполнено).ЭтоИстина(); 49 | ``` 50 | 51 | #### `ЭтоЛожь()` / `ЕстьЛожь()` 52 | 53 | Проверяет, что значение равно `Ложь`. 54 | 55 | ```bsl 56 | Ожидаем.Что(ОшибкаВозникла).ЭтоЛожь(); 57 | ``` 58 | 59 | #### `Равно(ОжидаемоеЗначение)` 60 | 61 | Проверяет равенство значений. 62 | 63 | ```bsl 64 | Ожидаем.Что(Результат).Равно(42); 65 | Ожидаем.Что(Статус).Равно("Готов"); 66 | ``` 67 | 68 | ### Числовые сравнения в BDD 69 | 70 | #### `Больше(МеньшееЗначение)` 71 | 72 | Проверяет, что значение больше указанного. 73 | 74 | ```bsl 75 | Ожидаем.Что(Количество).Больше(0); 76 | ``` 77 | 78 | #### `БольшеИлиРавно(МеньшееИлиРавноеЗначение)` / `Минимум(МинимальноеЗначение)` 79 | 80 | Проверяет, что значение больше или равно указанному. 81 | 82 | ```bsl 83 | Ожидаем.Что(Возраст).БольшеИлиРавно(18); 84 | Ожидаем.Что(Зарплата).Минимум(10000); 85 | ``` 86 | 87 | #### `Меньше(БольшееЗначение)` 88 | 89 | Проверяет, что значение меньше указанного. 90 | 91 | ```bsl 92 | Ожидаем.Что(ВремяОтклика).Меньше(1000); 93 | ``` 94 | 95 | #### `МеньшеИлиРавно(БольшееИлиРавноеЗначение)` / `Максимум(МаксимальноеЗначение)` 96 | 97 | Проверяет, что значение меньше или равно указанному. 98 | 99 | ```bsl 100 | Ожидаем.Что(Оценка).МеньшеИлиРавно(10); 101 | Ожидаем.Что(Размер).Максимум(1024); 102 | ``` 103 | 104 | #### `Между(НачальноеЗначение, КонечноеЗначение)` 105 | 106 | Проверяет, что значение находится в указанном диапазоне. 107 | 108 | ```bsl 109 | Ожидаем.Что(Процент).Между(0, 100); 110 | ``` 111 | 112 | ### Проверки существования и заполненности 113 | 114 | #### `Заполнено()` 115 | 116 | Проверяет, что значение заполнено. 117 | 118 | ```bsl 119 | Ожидаем.Что(НомерЗаказа).Заполнено(); 120 | ``` 121 | 122 | #### `Существует()` 123 | 124 | Проверяет, что значение не равно `Неопределено` и не равно `Null`. 125 | 126 | ```bsl 127 | Ожидаем.Что(НайденныйЭлемент).Существует(); 128 | ``` 129 | 130 | #### `ЭтоНеопределено()` / `ЕстьНеопределено()` 131 | 132 | Проверяет, что значение равно `Неопределено`. 133 | 134 | ```bsl 135 | Ожидаем.Что(НеинициализированнаяПеременная).ЭтоНеопределено(); 136 | ``` 137 | 138 | #### `ЭтоNull()` / `ЕстьNull()` 139 | 140 | Проверяет, что значение равно `Null`. 141 | 142 | ```bsl 143 | Ожидаем.Что(ПустаяСсылка).ЭтоNull(); 144 | ``` 145 | 146 | ### Проверки типов в BDD 147 | 148 | #### `ИмеетТип(ТипИлиИмяТипа)` 149 | 150 | Проверяет соответствие типа значения ожидаемому. 151 | 152 | ```bsl 153 | Ожидаем.Что(МойОбъект).ИмеетТип("Структура"); 154 | Ожидаем.Что(СписокЗначений).ИмеетТип(Тип("Массив")); 155 | ``` 156 | 157 | ### Работа с коллекциями 158 | 159 | #### `Содержит(ИскомоеЗначение)` 160 | 161 | Проверяет содержание элемента в коллекции или подстроки в строке. 162 | 163 | ```bsl 164 | // Для строк 165 | Ожидаем.Что(ТекстОшибки).Содержит("не найден"); 166 | 167 | // Для массивов 168 | Ожидаем.Что(СписокФайлов).Содержит("config.json"); 169 | 170 | // Для структур/соответствий - проверяет значения 171 | Ожидаем.Что(Настройки).Содержит("Администратор"); 172 | ``` 173 | 174 | #### `ИмеетДлину(ОжидаемаяДлина)` 175 | 176 | Проверяет длину строки или количество элементов в коллекции. 177 | 178 | ```bsl 179 | Ожидаем.Что(Пароль).ИмеетДлину(8); 180 | Ожидаем.Что(МассивДанных).ИмеетДлину(5); 181 | ``` 182 | 183 | ### Проверки методов и исключений 184 | 185 | #### `ИмеетМетод(ИмяМетода)` 186 | 187 | Проверяет наличие метода у объекта. 188 | 189 | ```bsl 190 | Ожидаем.Что(МойОбъект).ИмеетМетод("ВыполнитьОбработку"); 191 | ``` 192 | 193 | #### `Метод(ИмяМетода, ПараметрыМетода).ВыбрасываетИсключение(ФрагментИсключения)` 194 | 195 | Проверяет, что вызов метода вызывает исключение. 196 | 197 | ```bsl 198 | Ожидаем.Что(КалькуляторОбъект).Метод("Разделить", Новый Массив).ВыбрасываетИсключение("деление на ноль"); 199 | ``` 200 | 201 | ### Работа с таблицами значений 202 | 203 | #### `РавнаТаблице(ОжидаемоеЗначение, СравнитьТолькоСТруктуру = Ложь)` 204 | 205 | Сравнивает таблицы значений. 206 | 207 | ```bsl 208 | Ожидаем.Что(ПолученнаяТаблица).РавнаТаблице(ОжидаемаяТаблица); 209 | ``` 210 | 211 | #### `ИмеетРавнуюСтруктуруСТаблицей(ОжидаемоеЗначение)` 212 | 213 | Сравнивает только структуру таблиц (колонки и их типы). 214 | 215 | ```bsl 216 | Ожидаем.Что(НоваяТаблица).ИмеетРавнуюСтруктуруСТаблицей(ШаблонТаблицы); 217 | ``` 218 | 219 | #### `СодержитСтрокуТаблицы(ОжидаемоеЗначение)` 220 | 221 | Проверяет наличие строки с указанными значениями в таблице. 222 | 223 | ```bsl 224 | СтрокаПоиска = Новый Структура("Код, Наименование", "001", "Товар1"); 225 | Ожидаем.Что(ТаблицаТоваров).СодержитСтрокуТаблицы(СтрокаПоиска); 226 | ``` 227 | 228 | ### Модификаторы сравнения 229 | 230 | #### `БезУчетаПорядкаСтрок()` 231 | 232 | Игнорирует порядок строк при сравнении таблиц. 233 | 234 | ```bsl 235 | Ожидаем.Что(Таблица1).БезУчетаПорядкаСтрок().РавнаТаблице(Таблица2); 236 | ``` 237 | 238 | #### `БезУчетаПорядкаКолонок()` 239 | 240 | Игнорирует порядок колонок при сравнении таблиц. 241 | 242 | ```bsl 243 | Ожидаем.Что(Таблица1).БезУчетаПорядкаКолонок().РавнаТаблице(Таблица2); 244 | ``` 245 | 246 | #### `БезУчетаИменКолонок()` 247 | 248 | Игнорирует имена колонок при сравнении таблиц. 249 | 250 | ```bsl 251 | Ожидаем.Что(Таблица1).БезУчетаИменКолонок().РавнаТаблице(Таблица2); 252 | ``` 253 | 254 | #### `НеУчитыватьПорядокВМассиве()` 255 | 256 | Игнорирует порядок элементов при сравнении массивов. 257 | 258 | ```bsl 259 | Ожидаем.Что(Массив1).НеУчитыватьПорядокВМассиве().РавноМассиву(Массив2); 260 | ``` 261 | 262 | ### Продвинутые сравнения 263 | 264 | #### `Идентично(ОжидаемоеЗначение)` 265 | 266 | Выполняет глубокое сравнение объектов (структур, массивов, таблиц). 267 | 268 | ```bsl 269 | Ожидаем.Что(СложнаяСтруктура).Идентично(ОжидаемаяСтруктура); 270 | ``` 271 | 272 | #### `РавноМассиву(ОжидаемоеЗначение)` 273 | 274 | Сравнивает массивы с детальной диагностикой различий. 275 | 276 | ```bsl 277 | Ожидаем.Что(ПолученныйМассив).РавноМассиву(ОжидаемыйМассив); 278 | ``` 279 | 280 | #### `РавноСтруктуреИлиСоответствию(ОжидаемоеЗначение)` 281 | 282 | Сравнивает структуры или соответствия с детальной диагностикой. 283 | 284 | ```bsl 285 | Ожидаем.Что(НастройкиСистемы).РавноСтруктуреИлиСоответствию(ОжидаемыеНастройки); 286 | ``` 287 | 288 | ## Цепочки утверждений 289 | 290 | BDD стиль поддерживает цепочки утверждений для комплексных проверок: 291 | 292 | ```bsl 293 | Ожидаем.Что(Пользователь) 294 | .ИмеетТип("Структура") 295 | .Содержит("Администратор") 296 | .ИмеетДлину(3); 297 | 298 | Ожидаем.Что(Таблица) 299 | .БезУчетаПорядкаСтрок() 300 | .БезУчетаПорядкаКолонок() 301 | .РавнаТаблице(ЭталонТаблица); 302 | ``` 303 | ## Модуль "Утверждения" 304 | 305 | ### Основные проверки 306 | 307 | #### `Проверить(Условие, ДопСообщениеОшибки = "")` 308 | 309 | Проверяет, что условие истинно. 310 | 311 | ```bsl 312 | Утверждения.Проверить(Истина, "Условие должно быть истинным"); 313 | ``` 314 | 315 | #### `ПроверитьИстину(Условие, ДопСообщениеОшибки = "")` 316 | 317 | Синоним для `Проверить()`. Проверяет, что значение равно `Истина`. 318 | 319 | ```bsl 320 | Утверждения.ПроверитьИстину(ПолучитьБулевоЗначение()); 321 | ``` 322 | 323 | #### `ПроверитьЛожь(Условие, ДопСообщениеОшибки = "")` 324 | 325 | Проверяет, что значение равно `Ложь`. 326 | 327 | ```bsl 328 | Утверждения.ПроверитьЛожь(ПользовательНеАвторизован); 329 | ``` 330 | 331 | ### Сравнения значений 332 | 333 | #### `ПроверитьРавенство(ПервоеЗначение, ВтороеЗначение, ДопСообщениеОшибки = "")` 334 | 335 | Проверяет равенство двух значений. 336 | 337 | ```bsl 338 | Утверждения.ПроверитьРавенство(42, ПолучитьЧисло()); 339 | Утверждения.ПроверитьРавенство("Привет", ПолучитьСтроку()); 340 | ``` 341 | 342 | #### `ПроверитьНеРавенство(ПервоеЗначение, ВтороеЗначение, ДопСообщениеОшибки = "")` 343 | 344 | Проверяет неравенство двух значений. 345 | 346 | ```bsl 347 | Утверждения.ПроверитьНеРавенство("", ИмяПользователя); 348 | ``` 349 | 350 | ### Числовые сравнения 351 | 352 | #### `ПроверитьБольше(Больше, Меньше, ДопСообщениеОшибки = "")` 353 | 354 | Проверяет, что первое значение больше второго. 355 | 356 | ```bsl 357 | Утверждения.ПроверитьБольше(100, ПолученнаяСумма); 358 | ``` 359 | 360 | #### `ПроверитьБольшеИлиРавно(Больше, Меньше, ДопСообщениеОшибки = "")` 361 | 362 | Проверяет, что первое значение больше или равно второму. 363 | 364 | ```bsl 365 | Утверждения.ПроверитьБольшеИлиРавно(0, КоличествоЭлементов); 366 | ``` 367 | 368 | #### `ПроверитьМеньше(ПроверяемоеЗначение1, ПроверяемоеЗначение2, СообщениеОбОшибке = "")` 369 | 370 | Проверяет, что первое значение меньше второго. 371 | 372 | ```bsl 373 | Утверждения.ПроверитьМеньше(ВремяВыполнения, МаксимальноеВремя); 374 | ``` 375 | 376 | #### `ПроверитьМеньшеИлиРавно(ПроверяемоеЗначение1, ПроверяемоеЗначение2, СообщениеОбОшибке = "")` 377 | 378 | Проверяет, что первое значение меньше или равно второму. 379 | 380 | ```bsl 381 | Утверждения.ПроверитьМеньшеИлиРавно(РазмерФайла, МаксимальныйРазмер); 382 | ``` 383 | 384 | ### Проверки заполненности 385 | 386 | #### `ПроверитьЗаполненность(ПроверяемоеЗначение, ДопСообщениеОшибки = "")` 387 | 388 | Проверяет, что значение заполнено (с помощью `ЗначениеЗаполнено()`). 389 | 390 | ```bsl 391 | Утверждения.ПроверитьЗаполненность(НомерДокумента); 392 | Утверждения.ПроверитьЗаполненность(ДатаСоздания); 393 | ``` 394 | 395 | #### `ПроверитьНеЗаполненность(ПроверяемоеЗначение, ДопСообщениеОшибки = "")` 396 | 397 | Проверяет, что значение не заполнено. 398 | 399 | ```bsl 400 | Утверждения.ПроверитьНеЗаполненность(ДатаУдаления); 401 | ``` 402 | 403 | ### Проверки типов 404 | 405 | #### `ПроверитьТип(Значение, ТипИлиИмяТипа, ДопСообщениеОшибки = "")` 406 | 407 | Проверяет соответствие типа значения ожидаемому типу. 408 | 409 | ```bsl 410 | Утверждения.ПроверитьТип(ПолученныйОбъект, "Структура"); 411 | Утверждения.ПроверитьТип(ПолученныйОбъект, Тип("Массив")); 412 | ``` 413 | 414 | ### Проверки дат 415 | 416 | #### `ПроверитьДату(Дата, Период, ДопСообщениеОшибки = "")` 417 | 418 | Проверяет, что дата входит в указанный период. 419 | 420 | ```bsl 421 | Период = Новый Структура("ДатаНачала, ДатаОкончания", НачалоДня(ТекущаяДата()), КонецДня(ТекущаяДата())); 422 | Утверждения.ПроверитьДату(ДатаОперации, Период); 423 | ``` 424 | 425 | #### `ПроверитьРавенствоДатСТочностью2Секунды(Дата, Дата2, ДопСообщениеОшибки = "")` 426 | 427 | Проверяет равенство дат с точностью до 2 секунд. 428 | 429 | ```bsl 430 | Утверждения.ПроверитьРавенствоДатСТочностью2Секунды(ВремяВыполнения, ОжидаемоеВремя); 431 | ``` 432 | 433 | ### Строковые проверки 434 | 435 | #### `ПроверитьЧтоВСтрокеСодержатсяТолькоЦифры(ИсходнаяСтрока, ДопСообщениеОшибки = "")` 436 | 437 | Проверяет, что строка содержит только цифры. 438 | 439 | ```bsl 440 | Утверждения.ПроверитьЧтоВСтрокеСодержатсяТолькоЦифры(Телефон); 441 | ``` 442 | 443 | #### `ПроверитьВхождение(Строка, ПодстрокаПоиска, ДопСообщениеОшибки = "")` 444 | 445 | Проверяет, что строка содержит указанную подстроку. 446 | 447 | ```bsl 448 | Утверждения.ПроверитьВхождение(ОтветСервера, "success"); 449 | ``` 450 | 451 | ### Проверки исключений и методов 452 | 453 | #### `ПроверитьКодСОшибкой(Код, Ошибка, ДопСообщениеОшибки = "")` 454 | 455 | Проверяет, что выполнение кода вызывает ошибку с указанным текстом. 456 | 457 | ```bsl 458 | Утверждения.ПроверитьКодСОшибкой("ВызватьИсключение ""Тестовая ошибка""", "Тестовая ошибка"); 459 | ``` 460 | 461 | #### `ПроверитьМетодСуществует(Объект, ИмяМетода, ДопСообщениеОшибки = "")` 462 | 463 | Проверяет наличие метода у объекта. 464 | 465 | ```bsl 466 | Утверждения.ПроверитьМетодСуществует(МойОбъект, "ВыполнитьОбработку"); 467 | ``` -------------------------------------------------------------------------------- /src/Классы/БДДАссерт.os: -------------------------------------------------------------------------------- 1 | #Использовать "../internal" 2 | 3 | Перем ПроверяемоеЗначение; // Установленное проверяемое значение 4 | Перем ИмяМетода; // Имя проверяемого метода 5 | Перем ПараметрыМетода; // Параметры проверяемого метода 6 | Перем ДопСообщениеОшибки; // Пользовательское сообщение ошибки 7 | Перем ФлагОтрицания; // Нужно инвертировать результат проверки 8 | Перем ФлагОтрицанияДляСообщения; // Значение флага отрицания для вывода пользователю 9 | Перем ПараметрыСравненияТаблиц; // Настройки сравнения таблиц 10 | Перем ПараметрыСравненияМассивов; // Настройки сравнения массивов 11 | 12 | Функция Что(Знач ПроверяемоеЗначениеПараметр, Знач Сообщение = "") Экспорт 13 | ПроверяемоеЗначение = ПроверяемоеЗначениеПараметр; 14 | ДопСообщениеОшибки = Сообщение; 15 | ФлагОтрицания = Ложь; 16 | ФлагОтрицанияДляСообщения = Ложь; 17 | 18 | Возврат ЭтотОбъект; 19 | КонецФункции 20 | 21 | Процедура ПриСозданииОбъекта(Знач ПроверяемоеЗначениеПараметр, Знач Сообщение = "") 22 | ПроверяемоеЗначение = ПроверяемоеЗначениеПараметр; 23 | ДопСообщениеОшибки = Сообщение; 24 | ФлагОтрицания = Ложь; 25 | ФлагОтрицанияДляСообщения = Ложь; 26 | 27 | ПараметрыСравненияТаблиц = Новый Структура; 28 | ПараметрыСравненияТаблиц.Вставить("УчитыватьПорядокСтрок", Истина); 29 | ПараметрыСравненияТаблиц.Вставить("УчитыватьПорядокКолонок", Истина); 30 | ПараметрыСравненияТаблиц.Вставить("УчитыватьИменаКолонок", Истина); 31 | 32 | ПараметрыСравненияМассивов = Новый Структура; 33 | ПараметрыСравненияМассивов.Вставить("УчитыватьПорядокЗначений", Истина); 34 | КонецПроцедуры 35 | 36 | Функция Не_() Экспорт 37 | ФлагОтрицания = Истина; 38 | 39 | Возврат ЭтотОбъект; 40 | КонецФункции 41 | 42 | Функция ЭтоНе() Экспорт 43 | Возврат Не_(); 44 | КонецФункции 45 | 46 | Функция Метод(Знач ИмяМетодаПараметр, Знач ПараметрыМетодаПараметр = Неопределено) Экспорт 47 | ИмяМетода = ИмяМетодаПараметр; 48 | Если ПараметрыМетодаПараметр = Неопределено Тогда 49 | ПараметрыМетода = Новый Массив; 50 | Иначе 51 | ПараметрыМетода = ПараметрыМетодаПараметр; 52 | КонецЕсли; 53 | 54 | Возврат ЭтотОбъект; 55 | КонецФункции 56 | 57 | Функция ЭтоИстина() Экспорт 58 | Если Не ЛогическоеВыражениеВерно(ПроверяемоеЗначение = Истина) Тогда 59 | СообщениеОшибки = СформироватьСообщениеОбОшибке(ПредставлениеЗначения(), "является ИСТИНОЙ."); 60 | ВызватьОшибкуПроверки(СообщениеОшибки); 61 | КонецЕсли; 62 | 63 | Возврат ЭтотОбъект; 64 | КонецФункции 65 | 66 | Функция ЕстьИстина() Экспорт 67 | Возврат ЭтоИстина(); 68 | КонецФункции 69 | 70 | Функция ЭтоЛожь() Экспорт 71 | Если Не ЛогическоеВыражениеВерно(ПроверяемоеЗначение = Ложь) Тогда 72 | СообщениеОшибки = СформироватьСообщениеОбОшибке(ПредставлениеЗначения(), "является ЛОЖЬЮ."); 73 | ВызватьОшибкуПроверки(СообщениеОшибки); 74 | КонецЕсли; 75 | 76 | Возврат ЭтотОбъект; 77 | КонецФункции 78 | 79 | Функция ЕстьЛожь() Экспорт 80 | Возврат ЭтоЛожь(); 81 | КонецФункции 82 | 83 | Функция Равно(Знач ОжидаемоеЗначение) Экспорт 84 | Если Не ЛогическоеВыражениеВерно(ПроверяемоеЗначение = ОжидаемоеЗначение) Тогда 85 | СообщениеОшибки = СформироватьСообщениеОбОшибке(ПроверяемоеЗначение, "РАВНО (" + ОжидаемоеЗначение + ")."); 86 | Если ТипЗнч(ПроверяемоеЗначение) <> ТипЗнч(ОжидаемоеЗначение) Тогда 87 | СообщениеОшибки = СтрШаблон( 88 | "%1 89 | |Тип проверяемого значения (%2) НЕ РАВЕН типу ожидаемого значения (%3).", 90 | СообщениеОшибки, 91 | ТипЗнч(ПроверяемоеЗначение), 92 | ТипЗнч(ОжидаемоеЗначение) 93 | ); 94 | КонецЕсли; 95 | ВызватьОшибкуПроверки(СообщениеОшибки); 96 | КонецЕсли; 97 | 98 | Возврат ЭтотОбъект; 99 | КонецФункции 100 | 101 | Функция Больше(Знач МеньшееЗначение) Экспорт 102 | Если Не ЛогическоеВыражениеВерно(ПроверяемоеЗначение > МеньшееЗначение) Тогда 103 | СообщениеОшибки = СформироватьСообщениеОбОшибке(ПроверяемоеЗначение, "БОЛЬШЕ (" + МеньшееЗначение + ")."); 104 | ВызватьОшибкуПроверки(СообщениеОшибки); 105 | КонецЕсли; 106 | 107 | Возврат ЭтотОбъект; 108 | КонецФункции 109 | 110 | Функция БольшеИлиРавно(Знач МеньшееИлиРавноеЗначение) Экспорт 111 | Если Не ЛогическоеВыражениеВерно(ПроверяемоеЗначение >= МеньшееИлиРавноеЗначение) Тогда 112 | СообщениеОшибки = СформироватьСообщениеОбОшибке( 113 | ПроверяемоеЗначение, 114 | СтрШаблон("БОЛЬШЕ ИЛИ РАВНО (%1).", МеньшееИлиРавноеЗначение) 115 | ); 116 | ВызватьОшибкуПроверки(СообщениеОшибки); 117 | КонецЕсли; 118 | 119 | Возврат ЭтотОбъект; 120 | КонецФункции 121 | 122 | Функция Минимум(Знач МинимальноеЗначение) Экспорт 123 | Возврат БольшеИлиРавно(МинимальноеЗначение); 124 | КонецФункции 125 | 126 | Функция МеньшеИлиРавно(Знач БольшееИлиРавноеЗначение) Экспорт 127 | Если Не ЛогическоеВыражениеВерно(ПроверяемоеЗначение <= БольшееИлиРавноеЗначение) Тогда 128 | СообщениеОшибки = СформироватьСообщениеОбОшибке( 129 | ПроверяемоеЗначение, 130 | СтрШаблон("МЕНЬШЕ ИЛИ РАВНО (%1).", БольшееИлиРавноеЗначение) 131 | ); 132 | ВызватьОшибкуПроверки(СообщениеОшибки); 133 | КонецЕсли; 134 | 135 | Возврат ЭтотОбъект; 136 | КонецФункции 137 | 138 | Функция Максимум(Знач МаксимальноеЗначение) Экспорт 139 | Возврат МеньшеИлиРавно(МаксимальноеЗначение); 140 | КонецФункции 141 | 142 | Функция Меньше(Знач БольшееЗначение) Экспорт 143 | Если Не ЛогическоеВыражениеВерно(ПроверяемоеЗначение < БольшееЗначение) Тогда 144 | СообщениеОшибки = СформироватьСообщениеОбОшибке(ПроверяемоеЗначение, "МЕНЬШЕ (" + БольшееЗначение + ")."); 145 | ВызватьОшибкуПроверки(СообщениеОшибки); 146 | КонецЕсли; 147 | 148 | Возврат ЭтотОбъект; 149 | КонецФункции 150 | 151 | Функция Заполнено() Экспорт 152 | Если Не ЛогическоеВыражениеВерно(ЗначениеЗаполнено(ПроверяемоеЗначение)) Тогда 153 | СообщениеОшибки = СформироватьСообщениеОбОшибке(ПроверяемоеЗначение, "является ЗАПОЛНЕННЫМ."); 154 | ВызватьОшибкуПроверки(СообщениеОшибки); 155 | КонецЕсли; 156 | 157 | Возврат ЭтотОбъект; 158 | КонецФункции 159 | 160 | Функция Существует() Экспорт 161 | Если Не ЛогическоеВыражениеВерно(ПроверяемоеЗначение <> Неопределено И ПроверяемоеЗначение <> Null) Тогда 162 | СообщениеОшибки = СформироватьСообщениеОбОшибке(ПроверяемоеЗначение, "СУЩЕСТВУЕТ."); 163 | ВызватьОшибкуПроверки(СообщениеОшибки); 164 | КонецЕсли; 165 | 166 | Возврат ЭтотОбъект; 167 | КонецФункции 168 | 169 | Функция ЭтоНеопределено() Экспорт 170 | Если Не ЛогическоеВыражениеВерно(ПроверяемоеЗначение = Неопределено) Тогда 171 | СообщениеОшибки = СформироватьСообщениеОбОшибке(ПроверяемоеЗначение, "является НЕОПРЕДЕЛЕНО."); 172 | ВызватьОшибкуПроверки(СообщениеОшибки); 173 | КонецЕсли; 174 | 175 | Возврат ЭтотОбъект; 176 | КонецФункции 177 | 178 | Функция ЕстьНеопределено() Экспорт 179 | Возврат ЭтоНеопределено(); 180 | КонецФункции 181 | 182 | Функция ЭтоNull() Экспорт 183 | Если Не ЛогическоеВыражениеВерно(ПроверяемоеЗначение = Null) Тогда 184 | СообщениеОшибки = СформироватьСообщениеОбОшибке(ПроверяемоеЗначение, "является NULL."); 185 | ВызватьОшибкуПроверки(СообщениеОшибки); 186 | КонецЕсли; 187 | 188 | Возврат ЭтотОбъект; 189 | КонецФункции 190 | 191 | Функция ЕстьNull() Экспорт 192 | Возврат ЭтоNull(); 193 | КонецФункции 194 | 195 | Функция ИмеетТип(Знач ТипИлиИмяТипа) Экспорт 196 | ОжидаемыйТип = ?(ТипЗнч(ТипИлиИмяТипа) = Тип("Строка"), Тип(ТипИлиИмяТипа), ТипИлиИмяТипа); 197 | ТипПроверяемогоЗначения = ТипЗнч(ПроверяемоеЗначение); 198 | Если Не ЛогическоеВыражениеВерно(ТипПроверяемогоЗначения = ОжидаемыйТип) Тогда 199 | СообщениеОшибки = СформироватьСообщениеОбОшибке( 200 | СтрШаблон("тип - %1", ТипПроверяемогоЗначения), 201 | СтрШаблон("имеет тип (%1).", ОжидаемыйТип) 202 | ); 203 | ВызватьОшибкуПроверки(СообщениеОшибки); 204 | КонецЕсли; 205 | 206 | Возврат ЭтотОбъект; 207 | КонецФункции 208 | 209 | Функция Между(Знач НачальноеЗначение, Знач КонечноеЗначение) Экспорт 210 | Если Не ЛогическоеВыражениеВерно( 211 | ПроверяемоеЗначение >= НачальноеЗначение И ПроверяемоеЗначение <= КонечноеЗначение) Тогда 212 | 213 | СообщениеОшибки = СформироватьСообщениеОбОшибке( 214 | ПроверяемоеЗначение, 215 | СтрШаблон("МЕЖДУ (%1) и (%2).", НачальноеЗначение, КонечноеЗначение) 216 | ); 217 | ВызватьОшибкуПроверки(СообщениеОшибки); 218 | 219 | КонецЕсли; 220 | 221 | Возврат ЭтотОбъект; 222 | КонецФункции 223 | 224 | Функция Содержит(Знач ИскомоеЗначение) Экспорт 225 | 226 | ТипПроверяемогоЗначения = ТипЗнч(ПроверяемоеЗначение); 227 | 228 | Если ТипПроверяемогоЗначения = Тип("Строка") Тогда 229 | ИскомоеЗначениеНайдено = СодержитСтроку(ПроверяемоеЗначение, ИскомоеЗначение); 230 | ИначеЕсли ТипПроверяемогоЗначения = Тип("Массив") Тогда 231 | ИскомоеЗначениеНайдено = ПроверяемоеЗначение.Найти(ИскомоеЗначение) <> Неопределено; 232 | ИначеЕсли ТипПроверяемогоЗначения = Тип("Структура") 233 | Или ТипПроверяемогоЗначения = Тип("Соответствие") Тогда 234 | 235 | Для каждого КлючЗначение Из ПроверяемоеЗначение Цикл 236 | ИскомоеЗначениеНайдено = КлючЗначение.Значение = ИскомоеЗначение; 237 | Если ИскомоеЗначениеНайдено Тогда 238 | Прервать; 239 | КонецЕсли; 240 | КонецЦикла; 241 | 242 | ИначеЕсли ТипПроверяемогоЗначения = Тип("СписокЗначений") Тогда 243 | ИскомоеЗначениеНайдено = ПроверяемоеЗначение.НайтиПоЗначению(ИскомоеЗначение) <> Неопределено; 244 | ИначеЕсли ЭтоЧитаемаяКоллекция(ТипПроверяемогоЗначения) Тогда 245 | ИскомоеЗначениеНайдено = ПроверяемоеЗначение.Содержит(ИскомоеЗначение); 246 | ИначеЕсли ЭтоЧитаемаяКарта(ТипПроверяемогоЗначения) Тогда 247 | ИскомоеЗначениеНайдено = ПроверяемоеЗначение.СодержитЗначение(ИскомоеЗначение); 248 | Иначе 249 | 250 | ВызватьИсключение СтрШаблон( 251 | "Утверждение ""Содержит"" не умеет работать с типом <%1>, %2", 252 | ТипПроверяемогоЗначения, 253 | ФорматДСО(ДопСообщениеОшибки) 254 | ); 255 | 256 | КонецЕсли; 257 | 258 | Если Не ЛогическоеВыражениеВерно(ИскомоеЗначениеНайдено) Тогда 259 | СообщениеОшибки = СформироватьСообщениеОбОшибке(ПроверяемоеЗначение, "СОДЕРЖИТ (" + ИскомоеЗначение + ")."); 260 | ВызватьОшибкуПроверки(СообщениеОшибки); 261 | КонецЕсли; 262 | 263 | Возврат ЭтотОбъект; 264 | КонецФункции 265 | 266 | Функция ИмеетДлину(Знач ОжидаемаяДлина) Экспорт 267 | Перем ФактическаяДлина; 268 | 269 | ТипПроверяемогоЗначения = ТипЗнч(ПроверяемоеЗначение); 270 | Если ТипПроверяемогоЗначения = Тип("Строка") Тогда 271 | ФактическаяДлина = СтрДлина(ПроверяемоеЗначение); 272 | Иначе 273 | Попытка 274 | ФактическаяДлина = ПроверяемоеЗначение.Количество(); 275 | Исключение 276 | ФактическаяДлина = Неопределено; 277 | КонецПопытки; 278 | КонецЕсли; 279 | 280 | Если ФактическаяДлина = Неопределено Тогда 281 | СообщениеОшибки = СтрШаблон( 282 | "Утверждение ""ИмеетДлину"" не умеет работать с типом <%1>. %2", 283 | ТипПроверяемогоЗначения, 284 | ФорматДСО(ДопСообщениеОшибки) 285 | ); 286 | ВызватьИсключение СообщениеОшибки; 287 | КонецЕсли; 288 | 289 | Если Не ЛогическоеВыражениеВерно(ФактическаяДлина = ОжидаемаяДлина) Тогда 290 | СообщениеОшибки = СформироватьСообщениеОбОшибке( 291 | СтрШаблон("<%1> с длиной %2", ПроверяемоеЗначение, ФактическаяДлина), 292 | СтрШаблон("ИМЕЕТ ДЛИНУ (%1).", ОжидаемаяДлина) 293 | ); 294 | ВызватьОшибкуПроверки(СообщениеОшибки); 295 | КонецЕсли; 296 | 297 | Возврат ЭтотОбъект; 298 | КонецФункции 299 | 300 | Функция ВыбрасываетИсключение(Знач ФрагментИсключения = "") Экспорт 301 | Контекст = ПроверяемоеЗначение; 302 | ИсключениеВозникло = Ложь; 303 | 304 | Попытка 305 | Рефлектор = Новый Рефлектор; 306 | Рефлектор.ВызватьМетод(Контекст, ИмяМетода, ПараметрыМетода); 307 | Исключение 308 | ИсключениеВозникло = Истина; 309 | ТекстИсключения = ОписаниеОшибки(); 310 | ИнформацияОбОшибке = ИнформацияОбОшибке(); 311 | КонецПопытки; 312 | 313 | Если Не ЛогическоеВыражениеВерно( 314 | ИсключениеВозникло И 315 | ПустаяСтрока(ФрагментИсключения) Или СтрНайти(ТекстИсключения, ФрагментИсключения) > 0) Тогда 316 | 317 | СообщениеОшибки = СтрШаблон( 318 | "Ожидали, что %1 %2 ВЫБРОСИТ ИСКЛЮЧЕНИЕ %3", 319 | ИмяМетода, 320 | ?(ФлагОтрицанияДляСообщения, "НЕ", ""), 321 | ?(ЗначениеЗаполнено(ФрагментИсключения), 322 | СтрШаблон("СОДЕРЖАЩЕЕ ТЕКСТ <%1>, а был текст <%2>.", ФрагментИсключения, ТекстИсключения), 323 | ТекстИсключения 324 | ) 325 | ); 326 | 327 | ВызватьОшибкуПроверки(СообщениеОшибки, ИнформацияОбОшибке); 328 | 329 | КонецЕсли; 330 | 331 | Возврат ЭтотОбъект; 332 | КонецФункции 333 | 334 | // Проверяет существование метода с указанным именем 335 | // 336 | // Выбрасывает исключение, если метод отсутствует 337 | // 338 | // Параметры: 339 | // ИмяМетода - Строка - Имя метода, наличие которого требуется проверить 340 | // 341 | // Возвращаемое значение: 342 | // БДДАссерт - Текущий объект 343 | // 344 | Функция ИмеетМетод(Знач ИмяМетода) Экспорт 345 | Перем Рефлектор; 346 | 347 | Рефлектор = Новый Рефлектор; 348 | Если НЕ ЛогическоеВыражениеВерно(Рефлектор.МетодСуществует(ПроверяемоеЗначение, ИмяМетода)) Тогда 349 | ВызватьОшибкуПроверки("Ожидали что объект имеет метод с именем '" + ИмяМетода + "'" + ФорматДСО(ДопСообщениеОшибки)); 350 | КонецЕсли; 351 | 352 | Возврат ЭтотОбъект; 353 | КонецФункции 354 | 355 | Функция РавнаТаблице(Знач ОжидаемоеЗначение, Знач СравнитьТолькоСТруктуру = Ложь) Экспорт 356 | 357 | Различия = РазличияТаблиц(ПроверяемоеЗначение, ОжидаемоеЗначение, СравнитьТолькоСТруктуру); 358 | 359 | 360 | ВсеОК = Различия.Количество() = 0; 361 | ВсеОК = ?(ФлагОтрицания, Не ВсеОК, ВсеОК); 362 | 363 | ФлагОтрицанияДляСообщения = ФлагОтрицания; 364 | ФлагОтрицания = Ложь; 365 | 366 | Если Не ВсеОК Тогда 367 | СообщениеОшибки = СформироватьСообщениеОбОшибке(ПроверяемоеЗначение, "РАВНО (" + ОжидаемоеЗначение + "). 368 | |Различия таблиц:"); 369 | 370 | Для Каждого Различие Из Различия Цикл 371 | СообщениеОшибки = СтрШаблон("%1%2[%3:%4]: ожидали <%5>, а получили <%6>", СообщениеОшибки, Символы.ПС, 372 | Различие.Строка, Различие.Колонка, Различие.Ожидание, Различие.Результат); 373 | КонецЦикла; 374 | ВызватьОшибкуПроверки(СообщениеОшибки); 375 | КонецЕсли; 376 | 377 | Возврат ЭтотОбъект; 378 | КонецФункции 379 | 380 | Функция ИмеетРавнуюСтруктуруСТаблицей(Знач ОжидаемоеЗначение) Экспорт 381 | Возврат РавнаТаблице(ОжидаемоеЗначение, Истина); 382 | КонецФункции 383 | 384 | Функция СодержитСтрокуТаблицы(Знач ОжидаемоеЗначение) Экспорт 385 | 386 | СтруктураПоиска = Новый Структура(СтрСоединить(ИменаКолонок(ПроверяемоеЗначение), ",")); 387 | ЗаполнитьЗначенияСвойств(СтруктураПоиска, ОжидаемоеЗначение); 388 | 389 | НайденныеСтроки = ПроверяемоеЗначение.НайтиСтроки(СтруктураПоиска); 390 | 391 | ВсеОК = НайденныеСтроки.Количество() = 1; 392 | ВсеОК = ?(ФлагОтрицания, Не ВсеОК, ВсеОК); 393 | 394 | ФлагОтрицанияДляСообщения = ФлагОтрицания; 395 | ФлагОтрицания = Ложь; 396 | 397 | Если Не ВсеОК Тогда 398 | СообщениеОшибки = СформироватьСообщениеОбОшибке(ПроверяемоеЗначение, "СОДЕРЖИТ нужную строку."); 399 | ВызватьОшибкуПроверки(СообщениеОшибки); 400 | КонецЕсли; 401 | 402 | Возврат ЭтотОбъект; 403 | КонецФункции 404 | 405 | Функция БезУчетаПорядкаСтрок() Экспорт 406 | ПараметрыСравненияТаблиц.Вставить("УчитыватьПорядокСтрок", Ложь); 407 | 408 | Возврат ЭтотОбъект; 409 | КонецФункции 410 | 411 | Функция БезУчетаПорядкаКолонок() Экспорт 412 | ПараметрыСравненияТаблиц.Вставить("УчитыватьПорядокКолонок", Ложь); 413 | 414 | Возврат ЭтотОбъект; 415 | КонецФункции 416 | 417 | Функция БезУчетаИменКолонок() Экспорт 418 | ПараметрыСравненияТаблиц.Вставить("УчитыватьИменаКолонок", Ложь); 419 | 420 | Возврат ЭтотОбъект; 421 | КонецФункции 422 | 423 | Функция НеУчитыватьПорядокВМассиве() Экспорт 424 | ПараметрыСравненияМассивов.Вставить("УчитыватьПорядокЗначений", Ложь); 425 | 426 | Возврат ЭтотОбъект; 427 | КонецФункции 428 | 429 | Функция Идентично(Знач ОжидаемоеЗначение) Экспорт 430 | 431 | ТипОжидаемогоЗначения = ТипЗнч(ОжидаемоеЗначение); 432 | 433 | Флаги = СохранитьФлаги(); 434 | ИмеетТип(ТипОжидаемогоЗначения); 435 | ВосстановитьФлаги(Флаги); 436 | 437 | // Направляем в соответствующие методы в зависимости от типа 438 | Если ТипОжидаемогоЗначения = Тип("ТаблицаЗначений") Тогда 439 | РавнаТаблице(ОжидаемоеЗначение, Ложь); 440 | ИначеЕсли ТипОжидаемогоЗначения = Тип("Массив") Тогда 441 | РавноМассиву(ОжидаемоеЗначение); 442 | ИначеЕсли ТипОжидаемогоЗначения = Тип("Структура") 443 | Или ТипОжидаемогоЗначения = Тип("Соответствие") Тогда 444 | РавноСтруктуреИлиСоответствию(ОжидаемоеЗначение); 445 | Иначе 446 | // Для прочих типов используем обычное сравнение 447 | Равно(ОжидаемоеЗначение); 448 | КонецЕсли; 449 | 450 | Возврат ЭтотОбъект; 451 | КонецФункции 452 | 453 | Функция РавноМассиву(Знач ОжидаемоеЗначение) Экспорт 454 | 455 | Если Не ТипЗнч(ОжидаемоеЗначение) = Тип("Массив") Тогда 456 | СообщениеОшибки = СформироватьСообщениеОбОшибке(ОжидаемоеЗначение, "ИМЕЕТ ТИП <Массив>."); 457 | ВызватьОшибкуПроверки(СообщениеОшибки); 458 | КонецЕсли; 459 | 460 | // Используем функцию с детализацией 461 | РезультатСравнения = МассивыИдентичныСДетализацией(ПроверяемоеЗначение, ОжидаемоеЗначение, ""); 462 | Если Не ЛогическоеВыражениеВерно(РезультатСравнения.Идентичны) Тогда 463 | СообщениеОшибки = СформироватьСообщениеОбОшибке(ПроверяемоеЗначение, СтрШаблон("РАВНО массиву (%1)%2%3", 464 | ОжидаемоеЗначение, Символы.ПС, РезультатСравнения.ОписаниеОшибки)); 465 | ВызватьОшибкуПроверки(СообщениеОшибки); 466 | КонецЕсли; 467 | 468 | Возврат ЭтотОбъект; 469 | КонецФункции 470 | 471 | Функция РавноСтруктуреИлиСоответствию(Знач ОжидаемоеЗначение) Экспорт 472 | 473 | ТипОжидаемогоЗначения = ТипЗнч(ОжидаемоеЗначение); 474 | Если Не (ТипОжидаемогоЗначения = Тип("Структура") 475 | Или ТипОжидаемогоЗначения = Тип("Соответствие")) Тогда 476 | СообщениеОшибки = СформироватьСообщениеОбОшибке(ОжидаемоеЗначение, "ИМЕЕТ ТИП <Структура> или <Соответствие>."); 477 | ВызватьОшибкуПроверки(СообщениеОшибки); 478 | КонецЕсли; 479 | 480 | // Используем функцию с детализацией 481 | РезультатСравнения = СтруктурыИлиСоответствияИдентичныСДетализацией(ПроверяемоеЗначение, ОжидаемоеЗначение, ""); 482 | Если Не ЛогическоеВыражениеВерно(РезультатСравнения.Идентичны) Тогда 483 | ТипНазвание = ?(ТипОжидаемогоЗначения = Тип("Структура"), "структуре", "соответствию"); 484 | СообщениеОшибки = СформироватьСообщениеОбОшибке(ПроверяемоеЗначение, СтрШаблон("РАВНО %1 (%2)%3%4", 485 | ТипНазвание, ОжидаемоеЗначение, Символы.ПС, РезультатСравнения.ОписаниеОшибки)); 486 | ВызватьОшибкуПроверки(СообщениеОшибки); 487 | КонецЕсли; 488 | 489 | Возврат ЭтотОбъект; 490 | КонецФункции 491 | 492 | // Проверяет идентичность массивов с детализацией ошибок 493 | // Параметры: 494 | // Массив1 - Массив - первый массив для сравнения 495 | // Массив2 - Массив - второй массив для сравнения 496 | // ПутьКЭлементу - Строка - путь к текущему элементу для отчета об ошибке 497 | // Возвращаемое значение: 498 | // Структура - результат сравнения с полями Идентичны (Булево) и ОписаниеОшибки (Строка) 499 | Функция МассивыИдентичныСДетализацией(Знач Массив1, Знач Массив2, Знач ПутьКЭлементу) 500 | 501 | Результат = Новый Структура("Идентичны, ОписаниеОшибки", Истина, ""); 502 | 503 | // Проверяем типы 504 | Если ТипЗнч(Массив1) <> Тип("Массив") Или ТипЗнч(Массив2) <> Тип("Массив") Тогда 505 | Результат.Идентичны = Ложь; 506 | Результат.ОписаниеОшибки = СтрШаблон("Различие в %1: ожидался массив, но получен %2 и %3", 507 | ?(ПутьКЭлементу = "", "корне", ПутьКЭлементу), ТипЗнч(Массив1), ТипЗнч(Массив2)); 508 | Возврат Результат; 509 | КонецЕсли; 510 | 511 | // Проверяем длину 512 | Если Массив1.Количество() <> Массив2.Количество() Тогда 513 | Результат.Идентичны = Ложь; 514 | Результат.ОписаниеОшибки = СтрШаблон("Различие в %1: разное количество элементов - ожидалось %2, получено %3", 515 | ?(ПутьКЭлементу = "", "корне", ПутьКЭлементу), Массив2.Количество(), Массив1.Количество()); 516 | Возврат Результат; 517 | КонецЕсли; 518 | 519 | УчитыватьПорядокЗначений = Истина; 520 | Если ПараметрыСравненияМассивов.Свойство("УчитыватьПорядокЗначений") Тогда 521 | УчитыватьПорядокЗначений = ПараметрыСравненияМассивов.УчитыватьПорядокЗначений; 522 | КонецЕсли; 523 | 524 | Если УчитыватьПорядокЗначений Тогда 525 | // Проверяем все элементы по порядку 526 | Для Индекс = 0 По Массив1.Количество() - 1 Цикл 527 | НовыйПуть = ?(ПутьКЭлементу = "", СтрШаблон("[%1]", Индекс), СтрШаблон("%1[%2]", ПутьКЭлементу, Индекс)); 528 | РезультатСравненияЭлемента = ЭлементыИдентичныСДетализацией(Массив1[Индекс], Массив2[Индекс], НовыйПуть); 529 | Если Не РезультатСравненияЭлемента.Идентичны Тогда 530 | Результат.Идентичны = Ложь; 531 | Результат.ОписаниеОшибки = РезультатСравненияЭлемента.ОписаниеОшибки; 532 | Возврат Результат; 533 | КонецЕсли; 534 | КонецЦикла; 535 | Иначе 536 | // Сравниваем элементы без учета порядка (упрощенная реализация для детализации) 537 | ОжидаемыеЭлементы = Новый Массив; 538 | Для Каждого Элемент Из Массив2 Цикл 539 | ОжидаемыеЭлементы.Добавить(Элемент); 540 | КонецЦикла; 541 | 542 | Для ИндексФакт = 0 По Массив1.Количество() - 1 Цикл 543 | ФактическийЭлемент = Массив1[ИндексФакт]; 544 | НайденИндекс = -1; 545 | Для ИндексОжид = 0 По ОжидаемыеЭлементы.Количество() - 1 Цикл 546 | РезультатСравненияБазовый = ЭлементыИдентичныСДетализацией(ФактическийЭлемент, ОжидаемыеЭлементы[ИндексОжид], ""); 547 | Если РезультатСравненияБазовый.Идентичны Тогда 548 | НайденИндекс = ИндексОжид; 549 | Прервать; 550 | КонецЕсли; 551 | КонецЦикла; 552 | 553 | Если НайденИндекс = -1 Тогда 554 | Результат.Идентичны = Ложь; 555 | НовыйПуть = ?(ПутьКЭлементу = "", СтрШаблон("[%1]", ИндексФакт), СтрШаблон("%1[%2]", ПутьКЭлементу, ИндексФакт)); 556 | Результат.ОписаниеОшибки = СтрШаблон("Элемент %1 со значением %2 не найден в ожидаемом массиве", 557 | НовыйПуть, КраткоеПредставлениеЗначения(ФактическийЭлемент)); 558 | Возврат Результат; 559 | Иначе 560 | ОжидаемыеЭлементы.Удалить(НайденИндекс); 561 | КонецЕсли; 562 | КонецЦикла; 563 | КонецЕсли; 564 | 565 | Возврат Результат; 566 | КонецФункции 567 | 568 | // Проверяет идентичность структур или соответствий с детализацией ошибок 569 | // Параметры: 570 | // Объект1 - Структура, Соответствие - первый объект для сравнения 571 | // Объект2 - Структура, Соответствие - второй объект для сравнения 572 | // ПутьКЭлементу - Строка - путь к текущему элементу для отчета об ошибке 573 | // Возвращаемое значение: 574 | // Структура - результат сравнения с полями Идентичны (Булево) и ОписаниеОшибки (Строка) 575 | Функция СтруктурыИлиСоответствияИдентичныСДетализацией(Знач Объект1, Знач Объект2, Знач ПутьКЭлементу) 576 | 577 | Результат = Новый Структура("Идентичны, ОписаниеОшибки", Истина, ""); 578 | 579 | ТипОбъекта1 = ТипЗнч(Объект1); 580 | ТипОбъекта2 = ТипЗнч(Объект2); 581 | 582 | // Проверяем типы 583 | Если ТипОбъекта1 <> ТипОбъекта2 Тогда 584 | Результат.Идентичны = Ложь; 585 | Результат.ОписаниеОшибки = СтрШаблон("Различие в %1: ожидался %2, получен %3", 586 | ?(ПутьКЭлементу = "", "корне", ПутьКЭлементу), ТипОбъекта2, ТипОбъекта1); 587 | Возврат Результат; 588 | КонецЕсли; 589 | 590 | Если Не (ТипОбъекта1 = Тип("Структура") Или ТипОбъекта1 = Тип("Соответствие")) Тогда 591 | Результат.Идентичны = Ложь; 592 | Результат.ОписаниеОшибки = СтрШаблон("Различие в %1: ожидались структура или соответствие, получен %2", 593 | ?(ПутьКЭлементу = "", "корне", ПутьКЭлементу), ТипОбъекта1); 594 | Возврат Результат; 595 | КонецЕсли; 596 | 597 | // Проверяем количество элементов 598 | Если Объект1.Количество() <> Объект2.Количество() Тогда 599 | Результат.Идентичны = Ложь; 600 | Результат.ОписаниеОшибки = СтрШаблон("Различие в %1: разное количество элементов - ожидалось %2, получено %3", 601 | ?(ПутьКЭлементу = "", "корне", ПутьКЭлементу), Объект2.Количество(), Объект1.Количество()); 602 | Возврат Результат; 603 | КонецЕсли; 604 | 605 | // Проверяем все ключи и значения 606 | Для Каждого КлючЗначение Из Объект2 Цикл 607 | Ключ = КлючЗначение.Ключ; 608 | ОжидаемоеЗначение = КлючЗначение.Значение; 609 | 610 | Если Не СодержитКлюч(Объект1, Ключ) Тогда 611 | Результат.Идентичны = Ложь; 612 | НовыйПуть = ?(ПутьКЭлементу = "", СтрШаблон(".%1", Ключ), СтрШаблон("%1.%2", ПутьКЭлементу, Ключ)); 613 | Результат.ОписаниеОшибки = СтрШаблон("Ключ %1 отсутствует в фактическом объекте", НовыйПуть); 614 | Возврат Результат; 615 | КонецЕсли; 616 | 617 | ФактическоеЗначение = ПолучитьЗначениеПоКлючу(Объект1, Ключ); 618 | НовыйПуть = ?(ПутьКЭлементу = "", СтрШаблон(".%1", Ключ), СтрШаблон("%1.%2", ПутьКЭлементу, Ключ)); 619 | РезультатСравненияЗначения = ЭлементыИдентичныСДетализацией(ФактическоеЗначение, ОжидаемоеЗначение, НовыйПуть); 620 | Если Не РезультатСравненияЗначения.Идентичны Тогда 621 | Результат.Идентичны = Ложь; 622 | Результат.ОписаниеОшибки = РезультатСравненияЗначения.ОписаниеОшибки; 623 | Возврат Результат; 624 | КонецЕсли; 625 | КонецЦикла; 626 | 627 | // Проверяем, что в фактическом объекте нет лишних ключей 628 | Для Каждого КлючЗначение Из Объект1 Цикл 629 | Ключ = КлючЗначение.Ключ; 630 | Если Не СодержитКлюч(Объект2, Ключ) Тогда 631 | Результат.Идентичны = Ложь; 632 | НовыйПуть = ?(ПутьКЭлементу = "", СтрШаблон(".%1", Ключ), СтрШаблон("%1.%2", ПутьКЭлементу, Ключ)); 633 | Результат.ОписаниеОшибки = СтрШаблон("Лишний ключ %1 в фактическом объекте", НовыйПуть); 634 | Возврат Результат; 635 | КонецЕсли; 636 | КонецЦикла; 637 | 638 | Возврат Результат; 639 | КонецФункции 640 | 641 | // Рекурсивно проверяет идентичность двух элементов с детализацией ошибок 642 | // Параметры: 643 | // Элемент1 - Произвольный - первый элемент для сравнения 644 | // Элемент2 - Произвольный - второй элемент для сравнения 645 | // ПутьКЭлементу - Строка - путь к текущему элементу для отчета об ошибке 646 | // Возвращаемое значение: 647 | // Структура - результат сравнения с полями Идентичны (Булево) и ОписаниеОшибки (Строка) 648 | Функция ЭлементыИдентичныСДетализацией(Знач Элемент1, Знач Элемент2, Знач ПутьКЭлементу) 649 | 650 | Результат = Новый Структура("Идентичны, ОписаниеОшибки", Истина, ""); 651 | 652 | ТипЭлемента1 = ТипЗнч(Элемент1); 653 | ТипЭлемента2 = ТипЗнч(Элемент2); 654 | 655 | // Сначала проверяем типы 656 | Если ТипЭлемента1 <> ТипЭлемента2 Тогда 657 | Результат.Идентичны = Ложь; 658 | Результат.ОписаниеОшибки = СтрШаблон("Различие в %1: ожидался %2, получен %3", 659 | ?(ПутьКЭлементу = "", "корне", ПутьКЭлементу), ТипЭлемента2, ТипЭлемента1); 660 | Возврат Результат; 661 | КонецЕсли; 662 | 663 | // Для структур и соответствий 664 | Если ТипЭлемента1 = Тип("Структура") Или ТипЭлемента1 = Тип("Соответствие") Тогда 665 | Возврат СтруктурыИлиСоответствияИдентичныСДетализацией(Элемент1, Элемент2, ПутьКЭлементу); 666 | КонецЕсли; 667 | 668 | // Для массивов 669 | Если ТипЭлемента1 = Тип("Массив") Тогда 670 | Возврат МассивыИдентичныСДетализацией(Элемент1, Элемент2, ПутьКЭлементу); 671 | КонецЕсли; 672 | 673 | // Для таблиц значений 674 | Если ТипЭлемента1 = Тип("ТаблицаЗначений") Тогда 675 | // Используем существующую логику сравнения таблиц без детализации 676 | Различия = РазличияТаблиц(Элемент1, Элемент2, Ложь); 677 | Если Различия.Количество() > 0 Тогда 678 | Результат.Идентичны = Ложь; 679 | Результат.ОписаниеОшибки = СтрШаблон("Различие в %1: таблицы значений не идентичны", 680 | ?(ПутьКЭлементу = "", "корне", ПутьКЭлементу)); 681 | КонецЕсли; 682 | Возврат Результат; 683 | КонецЕсли; 684 | 685 | // Для остальных типов - простое сравнение 686 | Если Элемент1 <> Элемент2 Тогда 687 | Результат.Идентичны = Ложь; 688 | Результат.ОписаниеОшибки = СтрШаблон("Различие в %1: ожидалось %2, получено %3", 689 | ?(ПутьКЭлементу = "", "корне", ПутьКЭлементу), 690 | КраткоеПредставлениеЗначения(Элемент2), 691 | КраткоеПредставлениеЗначения(Элемент1)); 692 | КонецЕсли; 693 | 694 | Возврат Результат; 695 | КонецФункции 696 | 697 | // Возвращает краткое представление значения для сообщений об ошибках 698 | // Параметры: 699 | // Значение - Произвольный - значение для представления 700 | // Возвращаемое значение: 701 | // Строка - краткое представление значения 702 | Функция КраткоеПредставлениеЗначения(Знач Значение) 703 | 704 | ТипЗначения = ТипЗнч(Значение); 705 | 706 | Если Значение = Неопределено Тогда 707 | Возврат "Неопределено"; 708 | ИначеЕсли ТипЗначения = Тип("Строка") Тогда 709 | Если СтрДлина(Значение) > 50 Тогда 710 | Возврат """" + Лев(Значение, 47) + "..."""; 711 | Иначе 712 | Возврат """" + Значение + """"; 713 | КонецЕсли; 714 | ИначеЕсли ТипЗначения = Тип("Число") Или ТипЗначения = Тип("Булево") Тогда 715 | Возврат Строка(Значение); 716 | ИначеЕсли ТипЗначения = Тип("Дата") Тогда 717 | Возврат Формат(Значение, "ДФ=dd.MM.yyyy ВФ=HH:mm:ss"); 718 | ИначеЕсли ТипЗначения = Тип("Массив") Тогда 719 | Возврат СтрШаблон("Массив(%1)", Значение.Количество()); 720 | ИначеЕсли ТипЗначения = Тип("Структура") Тогда 721 | Возврат СтрШаблон("Структура(%1)", Значение.Количество()); 722 | ИначеЕсли ТипЗначения = Тип("Соответствие") Тогда 723 | Возврат СтрШаблон("Соответствие(%1)", Значение.Количество()); 724 | ИначеЕсли ТипЗначения = Тип("ТаблицаЗначений") Тогда 725 | Возврат СтрШаблон("ТаблицаЗначений(%1х%2)", Значение.Количество(), Значение.Колонки.Количество()); 726 | Иначе 727 | Возврат Строка(ТипЗначения); 728 | КонецЕсли; 729 | 730 | КонецФункции 731 | 732 | // Проверяет содержит ли объект указанный ключ 733 | Функция СодержитКлюч(Знач Объект, Знач Ключ) 734 | 735 | ТипОбъекта = ТипЗнч(Объект); 736 | 737 | Если ТипОбъекта = Тип("Структура") Тогда 738 | Возврат Объект.Свойство(Ключ); 739 | ИначеЕсли ТипОбъекта = Тип("Соответствие") Тогда 740 | Возврат Объект.Получить(Ключ) <> Неопределено; 741 | Иначе 742 | ВызватьИсключение "Неподдерживаемый тип объекта для проверки ключа: " + ТипОбъекта; 743 | КонецЕсли; 744 | 745 | КонецФункции 746 | 747 | // Получает значение по ключу из объекта 748 | Функция ПолучитьЗначениеПоКлючу(Знач Объект, Знач Ключ) 749 | 750 | ТипОбъекта = ТипЗнч(Объект); 751 | 752 | Если ТипОбъекта = Тип("Структура") Тогда 753 | Возврат Объект[Ключ]; 754 | ИначеЕсли ТипОбъекта = Тип("Соответствие") Тогда 755 | Возврат Объект.Получить(Ключ); 756 | Иначе 757 | ВызватьИсключение "Неподдерживаемый тип объекта для получения значения по ключу: " + ТипОбъекта; 758 | КонецЕсли; 759 | 760 | КонецФункции 761 | 762 | // { Helpers 763 | Функция ФорматДСО(Знач ДопСообщениеОшибки) 764 | Если ДопСообщениеОшибки = "" Тогда 765 | Возврат ""; 766 | КонецЕсли; 767 | 768 | Возврат Символы.ПС + ДопСообщениеОшибки; 769 | КонецФункции 770 | 771 | Процедура ВызватьОшибкуПроверки(Знач СообщениеОшибки, Знач Причина = Неопределено) 772 | 773 | ТекстИсключения = "[Failed] " + СообщениеОшибки; 774 | Попытка 775 | ВызватьИсключение ТекстИсключения; 776 | Исключение 777 | ИнформацияОбОшибке = ИнформацияОбОшибке(); 778 | СтекВызовов = ИнформацияОбОшибке.ПолучитьСтекВызовов(); 779 | МассивТекстИсключения = Новый Массив; 780 | МассивТекстИсключения.Добавить(ТекстИсключения); 781 | МассивТекстИсключения.Добавить("Стек трейс:"); 782 | 783 | Отступ = ""; 784 | СимволОтступа = " "; 785 | ПервыйКадр = Истина; 786 | Для Каждого КадрСтекаВызовов Из СтекВызовов Цикл 787 | // пропустим первый кадр стека, т.к. он ведет на служебный вызов исключения 788 | Если ПервыйКадр Тогда 789 | ПервыйКадр = Ложь; 790 | Продолжить; 791 | КонецЕсли; 792 | 793 | Отступ = Отступ + СимволОтступа; 794 | 795 | СтрокаСтекТрейса = СтрШаблон( 796 | "%1%2 / Метод %3 / Строка %4", 797 | Отступ, 798 | КадрСтекаВызовов.ИмяМодуля, 799 | КадрСтекаВызовов.Метод, 800 | Формат(КадрСтекаВызовов.НомерСтроки, "ЧГ=") 801 | ); 802 | МассивТекстИсключения.Добавить(СтрокаСтекТрейса); 803 | КонецЦикла; 804 | ТекстИсключения = СтрСоединить(МассивТекстИсключения, Символы.ПС); 805 | 806 | Контекст = Новый ИсключениеОшибкаУтверждения(); 807 | 808 | Если Число(Лев(Новый СистемнаяИнформация().Версия, 1)) >= 2 Тогда 809 | ВызватьИсключение Новый ИнформацияОбОшибке(ТекстИсключения, Контекст, Причина); 810 | Иначе 811 | ВызватьИсключение Новый ИнформацияОбОшибке(ТекстИсключения, Контекст); 812 | КонецЕсли; 813 | 814 | КонецПопытки; 815 | КонецПроцедуры 816 | 817 | Функция РазличияТаблиц(Знач ПроверяемоеЗначение, Знач ОжидаемоеЗначение, Знач СравнитьТолькоСтруктуру = Ложь) 818 | 819 | Различия = ПустаяТаблицаРазличийТаблиц(); 820 | 821 | Для Каждого Различие Из РазличияТиповТаблиц(ПроверяемоеЗначение, ОжидаемоеЗначение) Цикл 822 | ЗаполнитьЗначенияСвойств(Различия.Добавить(), Различие); 823 | КонецЦикла; 824 | 825 | Если Различия.Количество() > 0 Тогда 826 | Возврат Различия; 827 | КонецЕсли; 828 | 829 | Для Каждого Различие Из РазличияКолонокТаблиц(ПроверяемоеЗначение, ОжидаемоеЗначение) Цикл 830 | ЗаполнитьЗначенияСвойств(Различия.Добавить(), Различие); 831 | КонецЦикла; 832 | 833 | Если СравнитьТолькоСтруктуру Тогда 834 | Возврат Различия; 835 | КонецЕсли; 836 | 837 | Для Каждого Различие Из РазличияСтрокТаблиц(ПроверяемоеЗначение, ОжидаемоеЗначение) Цикл 838 | ЗаполнитьЗначенияСвойств(Различия.Добавить(), Различие); 839 | КонецЦикла; 840 | 841 | Возврат Различия; 842 | КонецФункции 843 | 844 | Функция ПустаяТаблицаРазличийТаблиц() 845 | 846 | Различия = Новый ТаблицаЗначений; 847 | Различия.Колонки.Добавить("Строка"); 848 | Различия.Колонки.Добавить("Колонка"); 849 | Различия.Колонки.Добавить("Ожидание"); 850 | Различия.Колонки.Добавить("Результат"); 851 | 852 | Возврат Различия; 853 | КонецФункции 854 | 855 | Функция РазличиеТаблиц(Знач Строка = "", Знач Колонка = "", Знач Ожидание = "", Знач Результат = "") 856 | 857 | Различие = ПустаяТаблицаРазличийТаблиц().Добавить(); 858 | Различие.Строка = Строка; 859 | Различие.Колонка = Колонка; 860 | Различие.Ожидание = Ожидание; 861 | Различие.Результат = Результат; 862 | 863 | Возврат Различие; 864 | КонецФункции 865 | 866 | Функция РазличияТиповТаблиц(Знач Таб1, Знач Таб2) 867 | 868 | Различия = ПустаяТаблицаРазличийТаблиц(); 869 | 870 | Если Не ТипЗнч(Таб1) = Тип("ТаблицаЗначений") Тогда 871 | Различие = РазличиеТаблиц("ПРОВЕРЯЕМОЕ значение", 872 | "Тип значения", 873 | "ТаблицаЗначений", 874 | ТипЗнч(Таб1)); 875 | ЗаполнитьЗначенияСвойств(Различия.Добавить(), Различие); 876 | КонецЕсли; 877 | Если Не ТипЗнч(Таб2) = Тип("ТаблицаЗначений") Тогда 878 | Различие = РазличиеТаблиц("ОЖИДАЕМОЕ значение", 879 | "Тип значения", 880 | "ТаблицаЗначений", 881 | ТипЗнч(Таб2)); 882 | ЗаполнитьЗначенияСвойств(Различия.Добавить(), Различие); 883 | КонецЕсли; 884 | 885 | Возврат Различия; 886 | КонецФункции 887 | 888 | Функция РазличияКолонокТаблиц(Знач Таб1, Знач Таб2) 889 | 890 | Различия = ПустаяТаблицаРазличийТаблиц(); 891 | 892 | Если Не Таб1.Колонки.Количество() = Таб2.Колонки.Количество() Тогда 893 | Различие = РазличиеТаблиц("ПРОВЕРЯЕМОЕ значение", 894 | "Количество КОЛОНОК", 895 | Таб2.Колонки.Количество(), 896 | Таб1.Колонки.Количество()); 897 | ЗаполнитьЗначенияСвойств(Различия.Добавить(), Различие); 898 | КонецЕсли; 899 | 900 | Если Не ПараметрыСравненияТаблиц.УчитыватьИменаКолонок Тогда 901 | Возврат Различия; 902 | КонецЕсли; 903 | 904 | Для Кол = 0 По Таб1.Колонки.Количество() - 1 Цикл 905 | Колонки = КолонкиТаблицПоИндексу(Таб1, Таб2, Кол); 906 | Если Колонки[2] = Неопределено Или Не Колонки[1].Имя = Колонки[2].Имя Тогда 907 | Ожидание = ?(Колонки[2] = Неопределено, "<ОТСУТСТВУЕТ>", СтрШаблон("колонку ""%1""", Колонки[2].Имя)); 908 | Результат = СтрШаблон("колонку ""%1""", Колонки[1].Имя); 909 | Различие = РазличиеТаблиц("ПРОВЕРЯЕМОЕ значение", "КОЛОНКИ", Ожидание, Результат); 910 | ЗаполнитьЗначенияСвойств(Различия.Добавить(), Различие); 911 | КонецЕсли; 912 | КонецЦикла; 913 | 914 | Возврат Различия; 915 | КонецФункции 916 | 917 | Функция КолонкиТаблицПоИндексу(Знач Таб1, Знач Таб2, Знач ИндексКолонки) 918 | 919 | КолонкаТаб1 = Таб1.Колонки[ИндексКолонки]; 920 | Если ПоискКолонкиПоИмени() Тогда 921 | КолонкаТаб2 = Таб2.Колонки.Найти(КолонкаТаб1.Имя); 922 | Иначе 923 | КолонкаТаб2 = ?(ИндексКолонки < Таб2.Колонки.Количество(), Таб2.Колонки[ИндексКолонки], Неопределено); 924 | КонецЕсли; 925 | 926 | Колонки = Новый Массив; 927 | Колонки.Добавить("Для нумерации с 1"); 928 | Колонки.Добавить(КолонкаТаб1); 929 | Колонки.Добавить(КолонкаТаб2); 930 | 931 | Возврат Колонки; 932 | КонецФункции 933 | 934 | Функция ПоискКолонкиПоИмени() 935 | Возврат ПараметрыСравненияТаблиц.УчитыватьИменаКолонок И Не ПараметрыСравненияТаблиц.УчитыватьПорядокКолонок; 936 | КонецФункции 937 | 938 | Функция РазличияСтрокТаблиц(Знач ПроверяемоеЗначение, Знач ОжидаемоеЗначение) 939 | 940 | Различия = ПустаяТаблицаРазличийТаблиц(); 941 | 942 | Если Не ПроверяемоеЗначение.Количество() = ОжидаемоеЗначение.Количество() Тогда 943 | Различие = РазличиеТаблиц("ПРОВЕРЯЕМОЕ значение", 944 | "Количество СТРОК", 945 | ОжидаемоеЗначение.Количество(), 946 | ПроверяемоеЗначение.Количество()); 947 | ЗаполнитьЗначенияСвойств(Различия.Добавить(), Различие); 948 | КонецЕсли; 949 | 950 | Если Различия.Количество() > 0 Тогда 951 | Возврат Различия; 952 | КонецЕсли; 953 | 954 | Если Не ПараметрыСравненияТаблиц.УчитыватьПорядокСтрок Тогда 955 | Таб1 = ПроверяемоеЗначение.Скопировать(); 956 | Таб2 = ОжидаемоеЗначение.Скопировать(); 957 | Таб1 = ОтсортироватьТаблицуПоВсемКолонкам(Таб1); 958 | Таб2 = ОтсортироватьТаблицуПоВсемКолонкам(Таб2); 959 | Иначе 960 | Таб1 = ПроверяемоеЗначение; 961 | Таб2 = ОжидаемоеЗначение; 962 | КонецЕсли; 963 | 964 | Для Стр = 0 По Таб1.Количество() - 1 Цикл 965 | Для Кол = 0 По Таб1.Колонки.Количество() - 1 Цикл 966 | Результат = Таб1[Стр][Кол]; 967 | Колонки = КолонкиТаблицПоИндексу(Таб1, Таб2, Кол); 968 | Ожидание = ?(Колонки[2] = Неопределено, "<НЕТ КОЛОНКИ>", Таб2[Стр][Колонки[2]]); 969 | Если Не Ожидание = Результат Тогда 970 | Различие = РазличиеТаблиц(Стр, Кол, Ожидание, Результат); 971 | ЗаполнитьЗначенияСвойств(Различия.Добавить(), Различие); 972 | КонецЕсли; 973 | КонецЦикла; 974 | КонецЦикла; 975 | 976 | Возврат Различия; 977 | КонецФункции 978 | 979 | Функция ОтсортироватьТаблицуПоВсемКолонкам(Знач ТЗ) 980 | 981 | ИменаКолонок = СтрСоединить(ИменаКолонок(ТЗ), ","); 982 | ТЗ.Сортировать(ИменаКолонок); 983 | 984 | Возврат ТЗ; 985 | КонецФункции 986 | 987 | Функция ИменаКолонок(Знач ТЗ) 988 | 989 | ИменаКолонок = Новый Массив; 990 | Для Каждого Колонка Из ТЗ.Колонки Цикл 991 | ИменаКолонок.Добавить(Колонка.Имя); 992 | КонецЦикла; 993 | 994 | Возврат ИменаКолонок; 995 | КонецФункции 996 | 997 | Функция ЛогическоеВыражениеВерно(Знач ЛогическоеВыражение) 998 | Результат = ФлагОтрицания <> ЛогическоеВыражение; 999 | ФлагОтрицанияДляСообщения = ФлагОтрицания; 1000 | ФлагОтрицания = Ложь; 1001 | 1002 | Возврат Результат; 1003 | КонецФункции 1004 | 1005 | Функция СформироватьСообщениеОбОшибке(Знач ПроверяемоеЗначение, Знач Ожидание) 1006 | Возврат "Ожидали, что проверяемое значение (" + ПроверяемоеЗначение + ")" + ?(ФлагОтрицанияДляСообщения, " НЕ ", " ") + Ожидание + ФорматДСО(ДопСообщениеОшибки); 1007 | КонецФункции 1008 | 1009 | Процедура ПроверитьЧтоМногострочнаяСтрокаСодержитПодстрокуБезУчетаНачальныхКонечныхПробеловВПодстроках(Знач Строка, Знач Подстрока, ДопСообщениеОшибки = "") 1010 | СообщениеОшибки = ""; 1011 | Нашли = МногострочнаяСтрокаСодержитПодстрокуБезУчетаНачальныхКонечныхПробеловВПодстроках(Строка, Подстрока, СообщениеОшибки); 1012 | Если Не Нашли Тогда 1013 | ВызватьОшибкуПроверки( СтрШаблон("Ожидали, что в строке < 1014 | |%1 1015 | |> 1016 | |найдем подстроку< 1017 | |%2 1018 | |> 1019 | |А это не так. 1020 | |Уточнение: %3. 1021 | |%4", Строка, Подстрока, СообщениеОшибки, ДопСообщениеОшибки)); 1022 | КонецЕсли; 1023 | КонецПроцедуры 1024 | 1025 | Функция МногострочнаяСтрокаСодержитПодстрокуБезУчетаНачальныхКонечныхПробеловВПодстроках(Знач Строка, Знач Подстрока, СообщениеОшибки = "") 1026 | ПерваяСтрока = СокрЛП(СтрПолучитьСтроку(Подстрока, 1)); 1027 | НашлиПервуюСтроку = Ложь; 1028 | Для Счетчик = 1 По СтрЧислоСтрок(Строка) Цикл 1029 | ОчереднаяСтрока = СокрЛП(СтрПолучитьСтроку(Строка, Счетчик)); 1030 | НашлиПервуюСтроку = Найти(ОчереднаяСтрока, ПерваяСтрока) <> 0; 1031 | Если НашлиПервуюСтроку Тогда 1032 | Прервать; 1033 | КонецЕсли; 1034 | КонецЦикла; 1035 | Если Не НашлиПервуюСтроку Тогда 1036 | СообщениеОшибки = СтрШаблон("Не нашли первую же подстроку <%1>", ПерваяСтрока); 1037 | Возврат Ложь; 1038 | КонецЕсли; 1039 | 1040 | СчетчикЧтоИщем = 2; 1041 | Для Счетчик = Счетчик+1 По СтрЧислоСтрок(Строка) Цикл 1042 | ОчереднаяСтрока = СокрЛП(СтрПолучитьСтроку(Строка, Счетчик)); 1043 | ЧтоИщем = СокрЛП(СтрПолучитьСтроку(Подстрока, СчетчикЧтоИщем)); 1044 | Поз = Найти(ОчереднаяСтрока, ЧтоИщем); 1045 | Если Поз = 0 Тогда 1046 | СообщениеОшибки = СтрШаблон("Не нашли подстроку № %1 <%2>", СчетчикЧтоИщем, ЧтоИщем); 1047 | Возврат Ложь; 1048 | Иначе 1049 | СчетчикЧтоИщем = СчетчикЧтоИщем + 1; 1050 | Если СчетчикЧтоИщем > СтрЧислоСтрок(Подстрока) Тогда 1051 | Возврат Истина; 1052 | КонецЕсли; 1053 | КонецЕсли; 1054 | КонецЦикла; 1055 | Возврат СчетчикЧтоИщем > СтрЧислоСтрок(Подстрока); 1056 | КонецФункции 1057 | 1058 | Функция ПредставлениеЗначения() 1059 | Если ТипЗнч(ПроверяемоеЗначение) = Тип("Булево") Тогда 1060 | Представление = Формат(ПроверяемоеЗначение, "БЛ=Ложь; БИ=Истина"); 1061 | Иначе 1062 | Представление = "" + ПроверяемоеЗначение; 1063 | КонецЕсли; 1064 | Возврат Представление; 1065 | КонецФункции 1066 | 1067 | Функция ЭтоЧитаемаяКоллекция(Тип) 1068 | Возврат УтвержденияСлужебный.КоллекшоносЗагружен() 1069 | И Новый Рефлектор().МетодСуществует(Тип, "Содержит"); 1070 | КонецФункции 1071 | 1072 | Функция ЭтоЧитаемаяКарта(Тип) 1073 | Возврат УтвержденияСлужебный.КоллекшоносЗагружен() 1074 | И Новый Рефлектор().МетодСуществует(Тип, "СодержитЗначение"); 1075 | КонецФункции 1076 | 1077 | Функция СодержитСтроку(ПроверяемоеЗначение, ИскомоеЗначение) 1078 | 1079 | Если СтрЧислоСтрок(ИскомоеЗначение) = 1 Тогда 1080 | Результат = СтрНайти(ПроверяемоеЗначение, ИскомоеЗначение) > 0; 1081 | Иначе 1082 | ПроверитьЧтоМногострочнаяСтрокаСодержитПодстрокуБезУчетаНачальныхКонечныхПробеловВПодстроках( 1083 | ПроверяемоеЗначение, 1084 | ИскомоеЗначение, ФорматДСО(ДопСообщениеОшибки) 1085 | ); 1086 | Результат = Истина; 1087 | КонецЕсли; 1088 | 1089 | Возврат Результат; 1090 | 1091 | КонецФункции 1092 | 1093 | Функция СохранитьФлаги() 1094 | 1095 | Результат = Новый Структура( 1096 | "ФлагОтрицания, ФлагОтрицанияДляСообщения", 1097 | ФлагОтрицания, 1098 | ФлагОтрицанияДляСообщения 1099 | ); 1100 | 1101 | ФлагОтрицания = Ложь; 1102 | ФлагОтрицанияДляСообщения = Ложь; 1103 | 1104 | Возврат Результат; 1105 | 1106 | КонецФункции 1107 | 1108 | Процедура ВосстановитьФлаги(Флаги) 1109 | 1110 | ФлагОтрицания = Флаги.ФлагОтрицания; 1111 | ФлагОтрицанияДляСообщения = Флаги.ФлагОтрицанияДляСообщения; 1112 | 1113 | КонецПроцедуры 1114 | 1115 | // } Helpers 1116 | -------------------------------------------------------------------------------- /tests/bdd-assertions-identity-tests.os: -------------------------------------------------------------------------------- 1 | &Тест 2 | Процедура ТестДолжен_Проверить_ИдентичностьСтроки() Экспорт 3 | // Arrange 4 | ОжидаемоеЗначение = "Привет, мир!"; 5 | ФактическоеЗначение = "Привет, мир!"; 6 | 7 | // Act & Assert 8 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 9 | КонецПроцедуры 10 | 11 | &Тест 12 | Процедура ТестДолжен_Проверить_НеИдентичностьСтроки() Экспорт 13 | // Arrange 14 | ОжидаемоеЗначение = "Привет, мир!"; 15 | ФактическоеЗначение = "Привет, Вася!"; 16 | 17 | // Act & Assert 18 | Ожидаем.Что(ФактическоеЗначение).Не_().Идентично(ОжидаемоеЗначение); 19 | КонецПроцедуры 20 | 21 | &Тест 22 | Процедура ТестДолжен_Проверить_ИдентичностьЧисел() Экспорт 23 | // Arrange 24 | ОжидаемоеЗначение = 42; 25 | ФактическоеЗначение = 42; 26 | 27 | // Act & Assert 28 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 29 | КонецПроцедуры 30 | 31 | &Тест 32 | Процедура ТестДолжен_Проверить_ИдентичностьБулевыхЗначений() Экспорт 33 | // Act & Assert 34 | Ожидаем.Что(Истина).Идентично(Истина); 35 | Ожидаем.Что(Ложь).Идентично(Ложь); 36 | КонецПроцедуры 37 | 38 | &Тест 39 | Процедура ТестДолжен_Проверить_ИдентичностьДат() Экспорт 40 | // Arrange 41 | ОжидаемоеЗначение = Дата("20250709120000"); 42 | ФактическоеЗначение = Дата("20250709120000"); 43 | 44 | // Act & Assert 45 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 46 | КонецПроцедуры 47 | 48 | &Тест 49 | Процедура ТестДолжен_Проверить_ИдентичностьНеопределено() Экспорт 50 | // Arrange 51 | ОжидаемоеЗначение = Неопределено; 52 | ФактическоеЗначение = Неопределено; 53 | 54 | // Act & Assert 55 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 56 | КонецПроцедуры 57 | 58 | &Тест 59 | Процедура ТестДолжен_Выбросить_Исключение_При_Разных_Типах() Экспорт 60 | // Arrange 61 | ПроверяемоеЗначение = "123"; 62 | ОжидаемоеЗначение = 123; 63 | 64 | // Act & Assert 65 | Попытка 66 | Ожидаем.Что(ПроверяемоеЗначение).Идентично(ОжидаемоеЗначение); 67 | Исключение 68 | // Ожидаемое поведение - исключение должно быть выброшено при сравнении разных типов 69 | Если СтрНайти( 70 | ИнформацияОбОшибке().Описание, 71 | "Ожидали, что проверяемое значение (тип - Строка) имеет тип (Число).") > 0 Тогда 72 | Возврат; 73 | КонецЕсли; 74 | КонецПопытки; 75 | 76 | ВызватьИсключение "Ожидали, что будет выброшено исключение при сравнении разных типов, а это не так"; 77 | КонецПроцедуры 78 | 79 | // Тесты для массивов 80 | 81 | &Тест 82 | Процедура ТестДолжен_Проверить_ИдентичностьПустыхМассивов() Экспорт 83 | // Arrange 84 | ОжидаемоеЗначение = Новый Массив; 85 | ФактическоеЗначение = Новый Массив; 86 | 87 | // Act & Assert 88 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 89 | КонецПроцедуры 90 | 91 | &Тест 92 | Процедура ТестДолжен_Проверить_ИдентичностьМассивов() Экспорт 93 | // Arrange 94 | ОжидаемоеЗначение = Новый Массив; 95 | ОжидаемоеЗначение.Добавить("элемент1"); 96 | ОжидаемоеЗначение.Добавить("элемент2"); 97 | ОжидаемоеЗначение.Добавить(123); 98 | 99 | ФактическоеЗначение = Новый Массив; 100 | ФактическоеЗначение.Добавить("элемент1"); 101 | ФактическоеЗначение.Добавить("элемент2"); 102 | ФактическоеЗначение.Добавить(123); 103 | 104 | // Act & Assert 105 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 106 | КонецПроцедуры 107 | 108 | &Тест 109 | Процедура ТестДолжен_Проверить_НеИдентичностьМассивовРазнойДлины() Экспорт 110 | // Arrange 111 | ОжидаемоеЗначение = Новый Массив; 112 | ОжидаемоеЗначение.Добавить("элемент1"); 113 | 114 | ФактическоеЗначение = Новый Массив; 115 | ФактическоеЗначение.Добавить("элемент1"); 116 | ФактическоеЗначение.Добавить("элемент2"); 117 | 118 | // Act & Assert 119 | Ожидаем.Что(ФактическоеЗначение).Не_().Идентично(ОжидаемоеЗначение); 120 | КонецПроцедуры 121 | 122 | &Тест 123 | Процедура ТестДолжен_Проверить_НеИдентичностьМассивовСРазнымиЭлементами() Экспорт 124 | // Arrange 125 | ОжидаемоеЗначение = Новый Массив; 126 | ОжидаемоеЗначение.Добавить("элемент1"); 127 | ОжидаемоеЗначение.Добавить("элемент2"); 128 | 129 | ФактическоеЗначение = Новый Массив; 130 | ФактическоеЗначение.Добавить("элемент1"); 131 | ФактическоеЗначение.Добавить("элемент3"); 132 | 133 | // Act & Assert 134 | Ожидаем.Что(ФактическоеЗначение).Не_().Идентично(ОжидаемоеЗначение); 135 | КонецПроцедуры 136 | 137 | &Тест 138 | Процедура ТестДолжен_Проверить_ИдентичностьВложенныхМассивов() Экспорт 139 | // Arrange 140 | ВложенныйМассив1 = Новый Массив; 141 | ВложенныйМассив1.Добавить("вложенный1"); 142 | ВложенныйМассив1.Добавить("вложенный2"); 143 | 144 | ВложенныйМассив2 = Новый Массив; 145 | ВложенныйМассив2.Добавить("вложенный1"); 146 | ВложенныйМассив2.Добавить("вложенный2"); 147 | 148 | ОжидаемоеЗначение = Новый Массив; 149 | ОжидаемоеЗначение.Добавить("элемент1"); 150 | ОжидаемоеЗначение.Добавить(ВложенныйМассив1); 151 | 152 | ФактическоеЗначение = Новый Массив; 153 | ФактическоеЗначение.Добавить("элемент1"); 154 | ФактическоеЗначение.Добавить(ВложенныйМассив2); 155 | 156 | // Act & Assert 157 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 158 | КонецПроцедуры 159 | 160 | &Тест 161 | Процедура ТестДолжен_Проверить_БезУчетаПорядкаЗначений() Экспорт 162 | // Arrange 163 | ОжидаемоеЗначение = Новый Массив; 164 | ОжидаемоеЗначение.Добавить("элемент1"); 165 | ОжидаемоеЗначение.Добавить("элемент2"); 166 | ОжидаемоеЗначение.Добавить("элемент3"); 167 | 168 | ФактическоеЗначение = Новый Массив; 169 | ФактическоеЗначение.Добавить("элемент3"); 170 | ФактическоеЗначение.Добавить("элемент1"); 171 | ФактическоеЗначение.Добавить("элемент2"); 172 | 173 | // Act & Assert 174 | Ожидаем.Что(ФактическоеЗначение).НеУчитыватьПорядокВМассиве().Идентично(ОжидаемоеЗначение); 175 | КонецПроцедуры 176 | 177 | // Тесты для структур 178 | 179 | &Тест 180 | Процедура ТестДолжен_Проверить_ИдентичностьПустыхСтруктур() Экспорт 181 | // Arrange 182 | ОжидаемоеЗначение = Новый Структура; 183 | ФактическоеЗначение = Новый Структура; 184 | 185 | // Act & Assert 186 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 187 | КонецПроцедуры 188 | 189 | &Тест 190 | Процедура ТестДолжен_Проверить_ИдентичностьСтруктур() Экспорт 191 | // Arrange 192 | ОжидаемоеЗначение = Новый Структура; 193 | ОжидаемоеЗначение.Вставить("Ключ1", "Значение1"); 194 | ОжидаемоеЗначение.Вставить("Ключ2", 123); 195 | ОжидаемоеЗначение.Вставить("Ключ3", Истина); 196 | 197 | ФактическоеЗначение = Новый Структура; 198 | ФактическоеЗначение.Вставить("Ключ1", "Значение1"); 199 | ФактическоеЗначение.Вставить("Ключ2", 123); 200 | ФактическоеЗначение.Вставить("Ключ3", Истина); 201 | 202 | // Act & Assert 203 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 204 | КонецПроцедуры 205 | 206 | &Тест 207 | Процедура ТестДолжен_Проверить_НеИдентичностьСтруктурСРазнымиКлючами() Экспорт 208 | // Arrange 209 | ОжидаемоеЗначение = Новый Структура; 210 | ОжидаемоеЗначение.Вставить("Ключ1", "Значение1"); 211 | ОжидаемоеЗначение.Вставить("Ключ2", 123); 212 | 213 | ФактическоеЗначение = Новый Структура; 214 | ФактическоеЗначение.Вставить("Ключ1", "Значение1"); 215 | ФактическоеЗначение.Вставить("Ключ3", 123); 216 | 217 | // Act & Assert 218 | Ожидаем.Что(ФактическоеЗначение).Не_().Идентично(ОжидаемоеЗначение); 219 | КонецПроцедуры 220 | 221 | &Тест 222 | Процедура ТестДолжен_Проверить_НеИдентичностьСтруктурСРазнымиЗначениями() Экспорт 223 | // Arrange 224 | ОжидаемоеЗначение = Новый Структура; 225 | ОжидаемоеЗначение.Вставить("Ключ1", "Значение1"); 226 | ОжидаемоеЗначение.Вставить("Ключ2", 123); 227 | 228 | ФактическоеЗначение = Новый Структура; 229 | ФактическоеЗначение.Вставить("Ключ1", "Значение1"); 230 | ФактическоеЗначение.Вставить("Ключ2", 456); 231 | 232 | // Act & Assert 233 | Ожидаем.Что(ФактическоеЗначение).Не_().Идентично(ОжидаемоеЗначение); 234 | КонецПроцедуры 235 | 236 | &Тест 237 | Процедура ТестДолжен_Проверить_ИдентичностьВложенныхСтруктур() Экспорт 238 | // Arrange 239 | ВложеннаяСтруктура1 = Новый Структура; 240 | ВложеннаяСтруктура1.Вставить("ВложенныйКлюч", "ВложенноеЗначение"); 241 | 242 | ВложеннаяСтруктура2 = Новый Структура; 243 | ВложеннаяСтруктура2.Вставить("ВложенныйКлюч", "ВложенноеЗначение"); 244 | 245 | ОжидаемоеЗначение = Новый Структура; 246 | ОжидаемоеЗначение.Вставить("Ключ1", "Значение1"); 247 | ОжидаемоеЗначение.Вставить("Структура", ВложеннаяСтруктура1); 248 | 249 | ФактическоеЗначение = Новый Структура; 250 | ФактическоеЗначение.Вставить("Ключ1", "Значение1"); 251 | ФактическоеЗначение.Вставить("Структура", ВложеннаяСтруктура2); 252 | 253 | // Act & Assert 254 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 255 | КонецПроцедуры 256 | 257 | // Тесты для соответствий 258 | 259 | &Тест 260 | Процедура ТестДолжен_Проверить_ИдентичностьПустыхСоответствий() Экспорт 261 | // Arrange 262 | ОжидаемоеЗначение = Новый Соответствие; 263 | ФактическоеЗначение = Новый Соответствие; 264 | 265 | // Act & Assert 266 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 267 | КонецПроцедуры 268 | 269 | &Тест 270 | Процедура ТестДолжен_Проверить_ИдентичностьСоответствий() Экспорт 271 | // Arrange 272 | ОжидаемоеЗначение = Новый Соответствие; 273 | ОжидаемоеЗначение.Вставить("Ключ1", "Значение1"); 274 | ОжидаемоеЗначение.Вставить("Ключ2", 123); 275 | 276 | ФактическоеЗначение = Новый Соответствие; 277 | ФактическоеЗначение.Вставить("Ключ1", "Значение1"); 278 | ФактическоеЗначение.Вставить("Ключ2", 123); 279 | 280 | // Act & Assert 281 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 282 | КонецПроцедуры 283 | 284 | &Тест 285 | Процедура ТестДолжен_Проверить_НеИдентичностьСоответствий() Экспорт 286 | // Arrange 287 | ОжидаемоеЗначение = Новый Соответствие; 288 | ОжидаемоеЗначение.Вставить("Ключ1", "Значение1"); 289 | ОжидаемоеЗначение.Вставить("Ключ2", 123); 290 | 291 | ФактическоеЗначение = Новый Соответствие; 292 | ФактическоеЗначение.Вставить("Ключ1", "Значение1"); 293 | ФактическоеЗначение.Вставить("Ключ2", 456); 294 | 295 | // Act & Assert 296 | Ожидаем.Что(ФактическоеЗначение).Не_().Идентично(ОжидаемоеЗначение); 297 | КонецПроцедуры 298 | 299 | // Тесты для таблиц значений 300 | 301 | &Тест 302 | Процедура ТестДолжен_Проверить_ИдентичностьПустыхТаблиц() Экспорт 303 | // Arrange 304 | ОжидаемоеЗначение = Новый ТаблицаЗначений; 305 | ФактическоеЗначение = Новый ТаблицаЗначений; 306 | 307 | // Act & Assert 308 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 309 | КонецПроцедуры 310 | 311 | &Тест 312 | Процедура ТестДолжен_Проверить_ИдентичностьТаблиц() Экспорт 313 | // Arrange 314 | ОжидаемоеЗначение = Новый ТаблицаЗначений; 315 | ОжидаемоеЗначение.Колонки.Добавить("Колонка1", Новый ОписаниеТипов("Строка")); 316 | ОжидаемоеЗначение.Колонки.Добавить("Колонка2", Новый ОписаниеТипов("Число")); 317 | 318 | НоваяСтрока = ОжидаемоеЗначение.Добавить(); 319 | НоваяСтрока.Колонка1 = "Значение1"; 320 | НоваяСтрока.Колонка2 = 123; 321 | 322 | ФактическоеЗначение = Новый ТаблицаЗначений; 323 | ФактическоеЗначение.Колонки.Добавить("Колонка1", Новый ОписаниеТипов("Строка")); 324 | ФактическоеЗначение.Колонки.Добавить("Колонка2", Новый ОписаниеТипов("Число")); 325 | 326 | НоваяСтрока = ФактическоеЗначение.Добавить(); 327 | НоваяСтрока.Колонка1 = "Значение1"; 328 | НоваяСтрока.Колонка2 = 123; 329 | 330 | // Act & Assert 331 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 332 | КонецПроцедуры 333 | 334 | &Тест 335 | Процедура ТестДолжен_Проверить_НеИдентичностьТаблиц() Экспорт 336 | // Arrange 337 | ОжидаемоеЗначение = Новый ТаблицаЗначений; 338 | ОжидаемоеЗначение.Колонки.Добавить("Колонка1", Новый ОписаниеТипов("Строка")); 339 | 340 | НоваяСтрока = ОжидаемоеЗначение.Добавить(); 341 | НоваяСтрока.Колонка1 = "Значение1"; 342 | 343 | ФактическоеЗначение = Новый ТаблицаЗначений; 344 | ФактическоеЗначение.Колонки.Добавить("Колонка1", Новый ОписаниеТипов("Строка")); 345 | 346 | НоваяСтрока = ФактическоеЗначение.Добавить(); 347 | НоваяСтрока.Колонка1 = "Значение2"; 348 | 349 | // Act & Assert 350 | Ожидаем.Что(ФактическоеЗначение).Не_().Идентично(ОжидаемоеЗначение); 351 | КонецПроцедуры 352 | 353 | // Тесты с отрицанием 354 | 355 | &Тест 356 | Процедура ТестДолжен_Проверить_ОтрицаниеИдентичности() Экспорт 357 | // Arrange 358 | ОжидаемоеЗначение = "Привет, мир!"; 359 | ФактическоеЗначение = "Привет, Вася!"; 360 | 361 | // Act & Assert 362 | Ожидаем.Что(ФактическоеЗначение).Не_().Идентично(ОжидаемоеЗначение); 363 | Ожидаем.Что(ФактическоеЗначение).ЭтоНе().Идентично(ОжидаемоеЗначение); 364 | КонецПроцедуры 365 | 366 | // Сложные тесты для комбинированных структур данных 367 | 368 | &Тест 369 | Процедура ТестДолжен_Проверить_ИдентичностьСложныхВложенныхСтруктур() Экспорт 370 | // Arrange 371 | ВложеннаяСтруктура1 = Новый Структура; 372 | ВложеннаяСтруктура1.Вставить("ИмяПользователя", "Иван"); 373 | ВложеннаяСтруктура1.Вставить("Возраст", 25); 374 | ВложеннаяСтруктура1.Вставить("Активен", Истина); 375 | 376 | МассивПравИдентичности1 = Новый Массив; 377 | МассивПравИдентичности1.Добавить("Чтение"); 378 | МассивПравИдентичности1.Добавить("Запись"); 379 | МассивПравИдентичности1.Добавить("Удаление"); 380 | 381 | ОжидаемоеЗначение = Новый Структура; 382 | ОжидаемоеЗначение.Вставить("Пользователь", ВложеннаяСтруктура1); 383 | ОжидаемоеЗначение.Вставить("Права", МассивПравИдентичности1); 384 | ОжидаемоеЗначение.Вставить("ДатаСоздания", '20250101000000'); 385 | 386 | // Создаем идентичную структуру 387 | ВложеннаяСтруктура2 = Новый Структура; 388 | ВложеннаяСтруктура2.Вставить("ИмяПользователя", "Иван"); 389 | ВложеннаяСтруктура2.Вставить("Возраст", 25); 390 | ВложеннаяСтруктура2.Вставить("Активен", Истина); 391 | 392 | МассивПравИдентичности2 = Новый Массив; 393 | МассивПравИдентичности2.Добавить("Чтение"); 394 | МассивПравИдентичности2.Добавить("Запись"); 395 | МассивПравИдентичности2.Добавить("Удаление"); 396 | 397 | ФактическоеЗначение = Новый Структура; 398 | ФактическоеЗначение.Вставить("Пользователь", ВложеннаяСтруктура2); 399 | ФактическоеЗначение.Вставить("Права", МассивПравИдентичности2); 400 | ФактическоеЗначение.Вставить("ДатаСоздания", '20250101000000'); 401 | 402 | // Act & Assert 403 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 404 | КонецПроцедуры 405 | 406 | &Тест 407 | Процедура ТестДолжен_Проверить_НеИдентичностьСложныхВложенныхСтруктурСРазнымиЗначениями() Экспорт 408 | // Arrange 409 | ВложеннаяСтруктура1 = Новый Структура; 410 | ВложеннаяСтруктура1.Вставить("ИмяПользователя", "Иван"); 411 | ВложеннаяСтруктура1.Вставить("Возраст", 25); 412 | 413 | МассивПрав1 = Новый Массив; 414 | МассивПрав1.Добавить("Чтение"); 415 | МассивПрав1.Добавить("Запись"); 416 | 417 | ОжидаемоеЗначение = Новый Структура; 418 | ОжидаемоеЗначение.Вставить("Пользователь", ВложеннаяСтруктура1); 419 | ОжидаемоеЗначение.Вставить("Права", МассивПрав1); 420 | 421 | // Создаем структуру с другими значениями во вложенном объекте 422 | ВложеннаяСтруктура2 = Новый Структура; 423 | ВложеннаяСтруктура2.Вставить("ИмяПользователя", "Петр"); // Отличается! 424 | ВложеннаяСтруктура2.Вставить("Возраст", 25); 425 | 426 | МассивПрав2 = Новый Массив; 427 | МассивПрав2.Добавить("Чтение"); 428 | МассивПрав2.Добавить("Запись"); 429 | 430 | ФактическоеЗначение = Новый Структура; 431 | ФактическоеЗначение.Вставить("Пользователь", ВложеннаяСтруктура2); 432 | ФактическоеЗначение.Вставить("Права", МассивПрав2); 433 | 434 | // Act & Assert 435 | Ожидаем.Что(ФактическоеЗначение).Не_().Идентично(ОжидаемоеЗначение); 436 | КонецПроцедуры 437 | 438 | &Тест 439 | Процедура ТестДолжен_Проверить_ИдентичностьМассивовСВложеннымиСтруктурами() Экспорт 440 | // Arrange 441 | Структура1 = Новый Структура; 442 | Структура1.Вставить("ID", 1); 443 | Структура1.Вставить("Название", "Первый элемент"); 444 | 445 | Структура2 = Новый Структура; 446 | Структура2.Вставить("ID", 2); 447 | Структура2.Вставить("Название", "Второй элемент"); 448 | 449 | ОжидаемоеЗначение = Новый Массив; 450 | ОжидаемоеЗначение.Добавить(Структура1); 451 | ОжидаемоеЗначение.Добавить(Структура2); 452 | 453 | // Создаем идентичные структуры 454 | Структура3 = Новый Структура; 455 | Структура3.Вставить("ID", 1); 456 | Структура3.Вставить("Название", "Первый элемент"); 457 | 458 | Структура4 = Новый Структура; 459 | Структура4.Вставить("ID", 2); 460 | Структура4.Вставить("Название", "Второй элемент"); 461 | 462 | ФактическоеЗначение = Новый Массив; 463 | ФактическоеЗначение.Добавить(Структура3); 464 | ФактическоеЗначение.Добавить(Структура4); 465 | 466 | // Act & Assert 467 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 468 | КонецПроцедуры 469 | 470 | &Тест 471 | Процедура ТестДолжен_Проверить_ИдентичностьМассивовСВложеннымиСтруктурамиБезУчетаПорядка() Экспорт 472 | // Arrange 473 | Структура1 = Новый Структура; 474 | Структура1.Вставить("ID", 1); 475 | Структура1.Вставить("Название", "Первый элемент"); 476 | 477 | Структура2 = Новый Структура; 478 | Структура2.Вставить("ID", 2); 479 | Структура2.Вставить("Название", "Второй элемент"); 480 | 481 | ОжидаемоеЗначение = Новый Массив; 482 | ОжидаемоеЗначение.Добавить(Структура1); 483 | ОжидаемоеЗначение.Добавить(Структура2); 484 | 485 | // Создаем идентичные структуры в другом порядке 486 | Структура3 = Новый Структура; 487 | Структура3.Вставить("ID", 2); 488 | Структура3.Вставить("Название", "Второй элемент"); 489 | 490 | Структура4 = Новый Структура; 491 | Структура4.Вставить("ID", 1); 492 | Структура4.Вставить("Название", "Первый элемент"); 493 | 494 | ФактическоеЗначение = Новый Массив; 495 | ФактическоеЗначение.Добавить(Структура3); // Второй 496 | ФактическоеЗначение.Добавить(Структура4); // Первый 497 | 498 | // Act & Assert 499 | Ожидаем.Что(ФактическоеЗначение).НеУчитыватьПорядокВМассиве().Идентично(ОжидаемоеЗначение); 500 | КонецПроцедуры 501 | 502 | &Тест 503 | Процедура ТестДолжен_Проверить_ИдентичностьСоответствийСВложеннымиМассивами() Экспорт 504 | // Arrange 505 | Массив1 = Новый Массив; 506 | Массив1.Добавить("элемент1"); 507 | Массив1.Добавить("элемент2"); 508 | 509 | Массив2 = Новый Массив; 510 | Массив2.Добавить(100); 511 | Массив2.Добавить(200); 512 | 513 | ОжидаемоеЗначение = Новый Соответствие; 514 | ОжидаемоеЗначение.Вставить("Строки", Массив1); 515 | ОжидаемоеЗначение.Вставить("Числа", Массив2); 516 | 517 | // Создаем идентичные массивы 518 | Массив3 = Новый Массив; 519 | Массив3.Добавить("элемент1"); 520 | Массив3.Добавить("элемент2"); 521 | 522 | Массив4 = Новый Массив; 523 | Массив4.Добавить(100); 524 | Массив4.Добавить(200); 525 | 526 | ФактическоеЗначение = Новый Соответствие; 527 | ФактическоеЗначение.Вставить("Строки", Массив3); 528 | ФактическоеЗначение.Вставить("Числа", Массив4); 529 | 530 | // Act & Assert 531 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 532 | КонецПроцедуры 533 | 534 | &Тест 535 | Процедура ТестДолжен_Проверить_ИдентичностьГлубокоВложенныхСтруктур() Экспорт 536 | // Arrange - создаем структуру с 3 уровнями вложенности 537 | УровеньТрети = Новый Структура; 538 | УровеньТрети.Вставить("ГлубокоеЗначение", "Самый внутренний"); 539 | 540 | УровеньВторой = Новый Структура; 541 | УровеньВторой.Вставить("ВторойУровень", "Средний"); 542 | УровеньВторой.Вставить("Вложенный", УровеньТрети); 543 | 544 | ОжидаемоеЗначение = Новый Структура; 545 | ОжидаемоеЗначение.Вставить("ПервыйУровень", "Внешний"); 546 | ОжидаемоеЗначение.Вставить("Вложенный", УровеньВторой); 547 | 548 | // Создаем идентичную структуру 549 | УровеньТретиКопия = Новый Структура; 550 | УровеньТретиКопия.Вставить("ГлубокоеЗначение", "Самый внутренний"); 551 | 552 | УровеньВторойКопия = Новый Структура; 553 | УровеньВторойКопия.Вставить("ВторойУровень", "Средний"); 554 | УровеньВторойКопия.Вставить("Вложенный", УровеньТретиКопия); 555 | 556 | ФактическоеЗначение = Новый Структура; 557 | ФактическоеЗначение.Вставить("ПервыйУровень", "Внешний"); 558 | ФактическоеЗначение.Вставить("Вложенный", УровеньВторойКопия); 559 | 560 | // Act & Assert 561 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 562 | КонецПроцедуры 563 | 564 | &Тест 565 | Процедура ТестДолжен_Проверить_НеИдентичностьГлубокоВложенныхСтруктурСОтличиемВГлубине() Экспорт 566 | // Arrange - создаем структуру с 3 уровнями вложенности 567 | УровеньТрети1 = Новый Структура; 568 | УровеньТрети1.Вставить("ГлубокоеЗначение", "Самый внутренний"); 569 | 570 | УровеньВторой1 = Новый Структура; 571 | УровеньВторой1.Вставить("ВторойУровень", "Средний"); 572 | УровеньВторой1.Вставить("Вложенный", УровеньТрети1); 573 | 574 | ОжидаемоеЗначение = Новый Структура; 575 | ОжидаемоеЗначение.Вставить("ПервыйУровень", "Внешний"); 576 | ОжидаемоеЗначение.Вставить("Вложенный", УровеньВторой1); 577 | 578 | // Создаем структуру с отличием на самом глубоком уровне 579 | УровеньТрети2 = Новый Структура; 580 | УровеньТрети2.Вставить("ГлубокоеЗначение", "Другое внутреннее значение"); // Отличается! 581 | 582 | УровеньВторой2 = Новый Структура; 583 | УровеньВторой2.Вставить("ВторойУровень", "Средний"); 584 | УровеньВторой2.Вставить("Вложенный", УровеньТрети2); 585 | 586 | ФактическоеЗначение = Новый Структура; 587 | ФактическоеЗначение.Вставить("ПервыйУровень", "Внешний"); 588 | ФактическоеЗначение.Вставить("Вложенный", УровеньВторой2); 589 | 590 | // Act & Assert 591 | Ожидаем.Что(ФактическоеЗначение).Не_().Идентично(ОжидаемоеЗначение); 592 | КонецПроцедуры 593 | 594 | &Тест 595 | Процедура ТестДолжен_Проверить_ИдентичностьСмешанныхТиповДанных() Экспорт 596 | // Arrange - создаем структуру со всеми типами данных 597 | МассивРазныхТипов = Новый Массив; 598 | МассивРазныхТипов.Добавить("Строка"); 599 | МассивРазныхТипов.Добавить(42); 600 | МассивРазныхТипов.Добавить(Истина); 601 | МассивРазныхТипов.Добавить('20250101000000'); 602 | МассивРазныхТипов.Добавить(Неопределено); 603 | 604 | ВложеннаяСтруктура = Новый Структура; 605 | ВложеннаяСтруктура.Вставить("Ключ", "Значение"); 606 | 607 | ВложенноеСоответствие = Новый Соответствие; 608 | ВложенноеСоответствие.Вставить("СоответствиеКлюч", "СоответствиеЗначение"); 609 | 610 | ОжидаемоеЗначение = Новый Структура; 611 | ОжидаемоеЗначение.Вставить("Массив", МассивРазныхТипов); 612 | ОжидаемоеЗначение.Вставить("Структура", ВложеннаяСтруктура); 613 | ОжидаемоеЗначение.Вставить("Соответствие", ВложенноеСоответствие); 614 | ОжидаемоеЗначение.Вставить("Строка", "Простая строка"); 615 | ОжидаемоеЗначение.Вставить("Число", 3.14); 616 | ОжидаемоеЗначение.Вставить("Булево", Ложь); 617 | 618 | // Создаем идентичную структуру 619 | МассивРазныхТиповКопия = Новый Массив; 620 | МассивРазныхТиповКопия.Добавить("Строка"); 621 | МассивРазныхТиповКопия.Добавить(42); 622 | МассивРазныхТиповКопия.Добавить(Истина); 623 | МассивРазныхТиповКопия.Добавить('20250101000000'); 624 | МассивРазныхТиповКопия.Добавить(Неопределено); 625 | 626 | ВложеннаяСтруктураКопия = Новый Структура; 627 | ВложеннаяСтруктураКопия.Вставить("Ключ", "Значение"); 628 | 629 | ВложенноеСоответствиеКопия = Новый Соответствие; 630 | ВложенноеСоответствиеКопия.Вставить("СоответствиеКлюч", "СоответствиеЗначение"); 631 | 632 | ФактическоеЗначение = Новый Структура; 633 | ФактическоеЗначение.Вставить("Массив", МассивРазныхТиповКопия); 634 | ФактическоеЗначение.Вставить("Структура", ВложеннаяСтруктураКопия); 635 | ФактическоеЗначение.Вставить("Соответствие", ВложенноеСоответствиеКопия); 636 | ФактическоеЗначение.Вставить("Строка", "Простая строка"); 637 | ФактическоеЗначение.Вставить("Число", 3.14); 638 | ФактическоеЗначение.Вставить("Булево", Ложь); 639 | 640 | // Act & Assert 641 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 642 | КонецПроцедуры 643 | 644 | &Тест 645 | Процедура ТестДолжен_Проверить_ИдентичностьМассивовСНулевымиЗначениями() Экспорт 646 | // Arrange 647 | ОжидаемоеЗначение = Новый Массив; 648 | ОжидаемоеЗначение.Добавить(Неопределено); 649 | ОжидаемоеЗначение.Добавить(Null); 650 | ОжидаемоеЗначение.Добавить(""); 651 | ОжидаемоеЗначение.Добавить(0); 652 | ОжидаемоеЗначение.Добавить(Ложь); 653 | 654 | ФактическоеЗначение = Новый Массив; 655 | ФактическоеЗначение.Добавить(Неопределено); 656 | ФактическоеЗначение.Добавить(Null); 657 | ФактическоеЗначение.Добавить(""); 658 | ФактическоеЗначение.Добавить(0); 659 | ФактическоеЗначение.Добавить(Ложь); 660 | 661 | // Act & Assert 662 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 663 | КонецПроцедуры 664 | 665 | &Тест 666 | Процедура ТестДолжен_Проверить_НеИдентичностьПриОтличииВНулевыхЗначениях() Экспорт 667 | // Arrange 668 | ОжидаемоеЗначение = Новый Массив; 669 | ОжидаемоеЗначение.Добавить(Неопределено); 670 | ОжидаемоеЗначение.Добавить(""); 671 | ОжидаемоеЗначение.Добавить(0); 672 | 673 | ФактическоеЗначение = Новый Массив; 674 | ФактическоеЗначение.Добавить(Null); // Отличается от Неопределено! 675 | ФактическоеЗначение.Добавить(""); 676 | ФактическоеЗначение.Добавить(0); 677 | 678 | // Act & Assert 679 | Ожидаем.Что(ФактическоеЗначение).Не_().Идентично(ОжидаемоеЗначение); 680 | КонецПроцедуры 681 | 682 | &Тест 683 | Процедура ТестДолжен_Проверить_ИдентичностьОченьГлубокойВложенности() Экспорт 684 | // Arrange - создаем структуру с глубокой вложенностью (10 уровней) 685 | ОжидаемоеЗначение = Новый Структура; 686 | ФактическоеЗначение = Новый Структура; 687 | 688 | ТекущаяСтруктураОжидаемая = ОжидаемоеЗначение; 689 | ТекущаяСтруктураФактическая = ФактическоеЗначение; 690 | 691 | Для Уровень = 1 По 10 Цикл 692 | СледующаяСтруктураОжидаемая = Новый Структура; 693 | СледующаяСтруктураФактическая = Новый Структура; 694 | 695 | СледующаяСтруктураОжидаемая.Вставить("Уровень", Уровень); 696 | СледующаяСтруктураОжидаемая.Вставить("Данные", "Уровень" + Формат(Уровень, "ЧГ=0")); 697 | 698 | СледующаяСтруктураФактическая.Вставить("Уровень", Уровень); 699 | СледующаяСтруктураФактическая.Вставить("Данные", "Уровень" + Формат(Уровень, "ЧГ=0")); 700 | 701 | ТекущаяСтруктураОжидаемая.Вставить("Следующий", СледующаяСтруктураОжидаемая); 702 | ТекущаяСтруктураФактическая.Вставить("Следующий", СледующаяСтруктураФактическая); 703 | 704 | ТекущаяСтруктураОжидаемая = СледующаяСтруктураОжидаемая; 705 | ТекущаяСтруктураФактическая = СледующаяСтруктураФактическая; 706 | КонецЦикла; 707 | 708 | // Act & Assert 709 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 710 | КонецПроцедуры 711 | 712 | &Тест 713 | Процедура ТестДолжен_Проверить_ИдентичностьМассиваВМассиве() Экспорт 714 | // Arrange - массивы, содержащие другие массивы в разных позициях 715 | ВложенныйМассив1 = Новый Массив; 716 | ВложенныйМассив1.Добавить("a"); 717 | ВложенныйМассив1.Добавить("b"); 718 | 719 | ВложенныйМассив2 = Новый Массив; 720 | ВложенныйМассив2.Добавить(1); 721 | ВложенныйМассив2.Добавить(2); 722 | 723 | ОжидаемоеЗначение = Новый Массив; 724 | ОжидаемоеЗначение.Добавить("начало"); 725 | ОжидаемоеЗначение.Добавить(ВложенныйМассив1); 726 | ОжидаемоеЗначение.Добавить("середина"); 727 | ОжидаемоеЗначение.Добавить(ВложенныйМассив2); 728 | ОжидаемоеЗначение.Добавить("конец"); 729 | 730 | // Создаем идентичную копию 731 | ВложенныйМассив1Копия = Новый Массив; 732 | ВложенныйМассив1Копия.Добавить("a"); 733 | ВложенныйМассив1Копия.Добавить("b"); 734 | 735 | ВложенныйМассив2Копия = Новый Массив; 736 | ВложенныйМассив2Копия.Добавить(1); 737 | ВложенныйМассив2Копия.Добавить(2); 738 | 739 | ФактическоеЗначение = Новый Массив; 740 | ФактическоеЗначение.Добавить("начало"); 741 | ФактическоеЗначение.Добавить(ВложенныйМассив1Копия); 742 | ФактическоеЗначение.Добавить("середина"); 743 | ФактическоеЗначение.Добавить(ВложенныйМассив2Копия); 744 | ФактическоеЗначение.Добавить("конец"); 745 | 746 | // Act & Assert 747 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 748 | КонецПроцедуры 749 | 750 | &Тест 751 | Процедура ТестДолжен_Проверить_НеИдентичностьМассивовСРазнымиВложенными() Экспорт 752 | // Arrange 753 | ВложенныйМассив1 = Новый Массив; 754 | ВложенныйМассив1.Добавить("a"); 755 | ВложенныйМассив1.Добавить("b"); 756 | 757 | ВложенныйМассив2 = Новый Массив; 758 | ВложенныйМассив2.Добавить("a"); 759 | ВложенныйМассив2.Добавить("c"); // Отличается! 760 | 761 | ОжидаемоеЗначение = Новый Массив; 762 | ОжидаемоеЗначение.Добавить("элемент"); 763 | ОжидаемоеЗначение.Добавить(ВложенныйМассив1); 764 | 765 | ФактическоеЗначение = Новый Массив; 766 | ФактическоеЗначение.Добавить("элемент"); 767 | ФактическоеЗначение.Добавить(ВложенныйМассив2); 768 | 769 | // Act & Assert 770 | Ожидаем.Что(ФактическоеЗначение).Не_().Идентично(ОжидаемоеЗначение); 771 | КонецПроцедуры 772 | 773 | &Тест 774 | Процедура ТестДолжен_Проверить_ИдентичностьСложнойИерархии() Экспорт 775 | // Arrange - создаем сложную иерархию с массивами, структурами и соответствиями 776 | 777 | // Подчиненные элементы 778 | Подчиненный1 = Новый Структура; 779 | Подчиненный1.Вставить("ID", 1); 780 | Подчиненный1.Вставить("Название", "Подчиненный 1"); 781 | Подчиненный1.Вставить("Активен", Истина); 782 | 783 | Подчиненный2 = Новый Структура; 784 | Подчиненный2.Вставить("ID", 2); 785 | Подчиненный2.Вставить("Название", "Подчиненный 2"); 786 | Подчиненный2.Вставить("Активен", Ложь); 787 | 788 | МассивПодчиненных = Новый Массив; 789 | МассивПодчиненных.Добавить(Подчиненный1); 790 | МассивПодчиненных.Добавить(Подчиненный2); 791 | 792 | // Основные данные 793 | Основные = Новый Структура; 794 | Основные.Вставить("Подчиненные", МассивПодчиненных); 795 | Основные.Вставить("Количество", МассивПодчиненных.Количество()); 796 | 797 | // Метаданные 798 | Метаданные = Новый Соответствие; 799 | Метаданные.Вставить("ВерсияСхемы", "1.0.0"); 800 | Метаданные.Вставить("ДатаСоздания", '20250109120000'); 801 | Метаданные.Вставить("Автор", "Система"); 802 | 803 | ОжидаемоеЗначение = Новый Структура; 804 | ОжидаемоеЗначение.Вставить("Основные", Основные); 805 | ОжидаемоеЗначение.Вставить("Метаданные", Метаданные); 806 | ОжидаемоеЗначение.Вставить("СтатусКод", 200); 807 | 808 | // Создаем идентичную копию 809 | Подчиненный1Копия = Новый Структура; 810 | Подчиненный1Копия.Вставить("ID", 1); 811 | Подчиненный1Копия.Вставить("Название", "Подчиненный 1"); 812 | Подчиненный1Копия.Вставить("Активен", Истина); 813 | 814 | Подчиненный2Копия = Новый Структура; 815 | Подчиненный2Копия.Вставить("ID", 2); 816 | Подчиненный2Копия.Вставить("Название", "Подчиненный 2"); 817 | Подчиненный2Копия.Вставить("Активен", Ложь); 818 | 819 | МассивПодчиненныхКопия = Новый Массив; 820 | МассивПодчиненныхКопия.Добавить(Подчиненный1Копия); 821 | МассивПодчиненныхКопия.Добавить(Подчиненный2Копия); 822 | 823 | ОсновныеКопия = Новый Структура; 824 | ОсновныеКопия.Вставить("Подчиненные", МассивПодчиненныхКопия); 825 | ОсновныеКопия.Вставить("Количество", МассивПодчиненныхКопия.Количество()); 826 | 827 | МетаданныеКопия = Новый Соответствие; 828 | МетаданныеКопия.Вставить("ВерсияСхемы", "1.0.0"); 829 | МетаданныеКопия.Вставить("ДатаСоздания", '20250109120000'); 830 | МетаданныеКопия.Вставить("Автор", "Система"); 831 | 832 | ФактическоеЗначение = Новый Структура; 833 | ФактическоеЗначение.Вставить("Основные", ОсновныеКопия); 834 | ФактическоеЗначение.Вставить("Метаданные", МетаданныеКопия); 835 | ФактическоеЗначение.Вставить("СтатусКод", 200); 836 | 837 | // Act & Assert 838 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 839 | КонецПроцедуры 840 | 841 | &Тест 842 | Процедура ТестДолжен_Проверить_НеИдентичностьПриОтличииВГлубине() Экспорт 843 | // Arrange - структуры идентичны, кроме одного значения глубоко внутри 844 | ВложеннаяСтруктура1 = Новый Структура; 845 | ВложеннаяСтруктура1.Вставить("Уровень3", "Значение1"); 846 | 847 | ВложеннаяСтруктура2 = Новый Структура; 848 | ВложеннаяСтруктура2.Вставить("Уровень3", "Значение2"); // Отличается! 849 | 850 | СтруктураУровень2_1 = Новый Структура; 851 | СтруктураУровень2_1.Вставить("Вложенная", ВложеннаяСтруктура1); 852 | 853 | СтруктураУровень2_2 = Новый Структура; 854 | СтруктураУровень2_2.Вставить("Вложенная", ВложеннаяСтруктура2); 855 | 856 | ОжидаемоеЗначение = Новый Структура; 857 | ОжидаемоеЗначение.Вставить("Уровень1", "Одинаково"); 858 | ОжидаемоеЗначение.Вставить("Уровень2", СтруктураУровень2_1); 859 | 860 | ФактическоеЗначение = Новый Структура; 861 | ФактическоеЗначение.Вставить("Уровень1", "Одинаково"); 862 | ФактическоеЗначение.Вставить("Уровень2", СтруктураУровень2_2); 863 | 864 | // Act & Assert 865 | Ожидаем.Что(ФактическоеЗначение).Не_().Идентично(ОжидаемоеЗначение); 866 | КонецПроцедуры 867 | 868 | &Тест 869 | Процедура ТестДолжен_Проверить_ИдентичностьМассивовСРазнымПорядкомВСоответствии() Экспорт 870 | // Arrange - тестируем сложный случай с порядком в соответствии 871 | Массив1 = Новый Массив; 872 | Массив1.Добавить("элемент1"); 873 | Массив1.Добавить("элемент2"); 874 | Массив1.Добавить("элемент3"); 875 | 876 | Массив2 = Новый Массив; 877 | Массив2.Добавить("элемент3"); // Другой порядок 878 | Массив2.Добавить("элемент1"); 879 | Массив2.Добавить("элемент2"); 880 | 881 | ОжидаемоеЗначение = Новый Соответствие; 882 | ОжидаемоеЗначение.Вставить("Ключ1", Массив1); 883 | ОжидаемоеЗначение.Вставить("Ключ2", "Простое значение"); 884 | 885 | ФактическоеЗначение = Новый Соответствие; 886 | ФактическоеЗначение.Вставить("Ключ1", Массив2); 887 | ФактическоеЗначение.Вставить("Ключ2", "Простое значение"); 888 | 889 | // Act & Assert - с учетом порядка должны быть НЕ идентичны 890 | Ожидаем.Что(ФактическоеЗначение).Не_().Идентично(ОжидаемоеЗначение); 891 | 892 | // А без учета порядка - идентичны 893 | Ожидаем.Что(ФактическоеЗначение).НеУчитыватьПорядокВМассиве().Идентично(ОжидаемоеЗначение); 894 | КонецПроцедуры 895 | 896 | &Тест 897 | Процедура ТестДолжен_Проверить_ИдентичностьБольшихОбъемовДанных() Экспорт 898 | // Arrange - создаем достаточно большие структуры данных 899 | КоличествоЭлементов = 100; 900 | 901 | ОжидаемоеЗначение = Новый Структура; 902 | ФактическоеЗначение = Новый Структура; 903 | 904 | // Массив с множеством элементов 905 | БольшойМассив1 = Новый Массив; 906 | БольшойМассив2 = Новый Массив; 907 | 908 | Для Индекс = 1 По КоличествоЭлементов Цикл 909 | ЭлементМассива = Новый Структура; 910 | ЭлементМассива.Вставить("Индекс", Индекс); 911 | ЭлементМассива.Вставить("Значение", "Элемент_" + Формат(Индекс, "ЧГ=0")); 912 | ЭлементМассива.Вставить("Активен", Индекс % 2 = 1); 913 | 914 | БольшойМассив1.Добавить(ЭлементМассива); 915 | 916 | // Создаем копию элемента 917 | ЭлементМассиваКопия = Новый Структура; 918 | ЭлементМассиваКопия.Вставить("Индекс", Индекс); 919 | ЭлементМассиваКопия.Вставить("Значение", "Элемент_" + Формат(Индекс, "ЧГ=0")); 920 | ЭлементМассиваКопия.Вставить("Активен", Индекс % 2 = 1); 921 | 922 | БольшойМассив2.Добавить(ЭлементМассиваКопия); 923 | КонецЦикла; 924 | 925 | ОжидаемоеЗначение.Вставить("БольшойМассив", БольшойМассив1); 926 | ОжидаемоеЗначение.Вставить("РазмерМассива", БольшойМассив1.Количество()); 927 | 928 | ФактическоеЗначение.Вставить("БольшойМассив", БольшойМассив2); 929 | ФактическоеЗначение.Вставить("РазмерМассива", БольшойМассив2.Количество()); 930 | 931 | // Act & Assert 932 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 933 | КонецПроцедуры 934 | 935 | &Тест 936 | Процедура ТестДолжен_Проверить_НеИдентичностьПриОтличииВБольшихДанных() Экспорт 937 | // Arrange - создаем большие структуры с одним отличием 938 | КоличествоЭлементов = 50; 939 | 940 | ОжидаемоеЗначение = Новый Массив; 941 | ФактическоеЗначение = Новый Массив; 942 | 943 | Для Индекс = 1 По КоличествоЭлементов Цикл 944 | Если Индекс = КоличествоЭлементов / 2 Тогда 945 | // В середине делаем отличие 946 | ОжидаемоеЗначение.Добавить("Отличается1"); 947 | ФактическоеЗначение.Добавить("Отличается2"); 948 | Иначе 949 | ЗначениеЭлемента = "Элемент_" + Формат(Индекс, "ЧГ=0"); 950 | ОжидаемоеЗначение.Добавить(ЗначениеЭлемента); 951 | ФактическоеЗначение.Добавить(ЗначениеЭлемента); 952 | КонецЕсли; 953 | КонецЦикла; 954 | 955 | // Act & Assert 956 | Ожидаем.Что(ФактическоеЗначение).Не_().Идентично(ОжидаемоеЗначение); 957 | КонецПроцедуры 958 | 959 | &Тест 960 | Процедура ТестДолжен_Проверить_ИдентичностьСпециальныхСимволов() Экспорт 961 | // Arrange - проверяем строки со специальными символами 962 | ОжидаемоеЗначение = Новый Структура; 963 | ОжидаемоеЗначение.Вставить("ПереносСтроки", "Строка1" + Символы.ПС + "Строка2"); 964 | ОжидаемоеЗначение.Вставить("Табуляция", "Колонка1" + Символы.Таб + "Колонка2"); 965 | ОжидаемоеЗначение.Вставить("Кавычки", "Текст ""в кавычках"""); 966 | ОжидаемоеЗначение.Вставить("Слэш", "Путь\к\файлу"); 967 | ОжидаемоеЗначение.Вставить("Unicode", "Тест с эмодзи: 😀🎉"); 968 | 969 | ФактическоеЗначение = Новый Структура; 970 | ФактическоеЗначение.Вставить("ПереносСтроки", "Строка1" + Символы.ПС + "Строка2"); 971 | ФактическоеЗначение.Вставить("Табуляция", "Колонка1" + Символы.Таб + "Колонка2"); 972 | ФактическоеЗначение.Вставить("Кавычки", "Текст ""в кавычках"""); 973 | ФактическоеЗначение.Вставить("Слэш", "Путь\к\файлу"); 974 | ФактическоеЗначение.Вставить("Unicode", "Тест с эмодзи: 😀🎉"); 975 | 976 | // Act & Assert 977 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 978 | КонецПроцедуры 979 | 980 | &Тест 981 | Процедура ТестДолжен_Проверить_ИдентичностьЧисловыхТипов() Экспорт 982 | // Arrange - проверяем разные числовые типы 983 | ОжидаемоеЗначение = Новый Структура; 984 | ОжидаемоеЗначение.Вставить("Целое", 42); 985 | ОжидаемоеЗначение.Вставить("Дробное", 3.14159); 986 | ОжидаемоеЗначение.Вставить("Ноль", 0); 987 | ОжидаемоеЗначение.Вставить("Отрицательное", -123); 988 | ОжидаемоеЗначение.Вставить("БольшоеЧисло", 999999999999); 989 | ОжидаемоеЗначение.Вставить("МалоеДробное", 0.0001); 990 | 991 | ФактическоеЗначение = Новый Структура; 992 | ФактическоеЗначение.Вставить("Целое", 42); 993 | ФактическоеЗначение.Вставить("Дробное", 3.14159); 994 | ФактическоеЗначение.Вставить("Ноль", 0); 995 | ФактическоеЗначение.Вставить("Отрицательное", -123); 996 | ФактическоеЗначение.Вставить("БольшоеЧисло", 999999999999); 997 | ФактическоеЗначение.Вставить("МалоеДробное", 0.0001); 998 | 999 | // Act & Assert 1000 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 1001 | КонецПроцедуры 1002 | 1003 | &Тест 1004 | Процедура ТестДолжен_Проверить_НеИдентичностьПохожихЧисел() Экспорт 1005 | // Arrange - числа, которые выглядят похоже, но не равны 1006 | ОжидаемоеЗначение = Новый Массив; 1007 | ОжидаемоеЗначение.Добавить(3.14159); 1008 | ОжидаемоеЗначение.Добавить(1); 1009 | ОжидаемоеЗначение.Добавить(0); 1010 | 1011 | ФактическоеЗначение = Новый Массив; 1012 | ФактическоеЗначение.Добавить(3.14158); // Отличается в последней цифре 1013 | ФактическоеЗначение.Добавить(1); 1014 | ФактическоеЗначение.Добавить(0); 1015 | 1016 | // Act & Assert 1017 | Ожидаем.Что(ФактическоеЗначение).Не_().Идентично(ОжидаемоеЗначение); 1018 | КонецПроцедуры 1019 | 1020 | &Тест 1021 | Процедура ТестДолжен_Проверить_ИдентичностьМногомерныхМассивов() Экспорт 1022 | // Arrange - создаем "многомерный" массив (массив массивов) 1023 | Строка1 = Новый Массив; 1024 | Строка1.Добавить(1); 1025 | Строка1.Добавить(2); 1026 | Строка1.Добавить(3); 1027 | 1028 | Строка2 = Новый Массив; 1029 | Строка2.Добавить(4); 1030 | Строка2.Добавить(5); 1031 | Строка2.Добавить(6); 1032 | 1033 | Строка3 = Новый Массив; 1034 | Строка3.Добавить(7); 1035 | Строка3.Добавить(8); 1036 | Строка3.Добавить(9); 1037 | 1038 | ОжидаемоеЗначение = Новый Массив; 1039 | ОжидаемоеЗначение.Добавить(Строка1); 1040 | ОжидаемоеЗначение.Добавить(Строка2); 1041 | ОжидаемоеЗначение.Добавить(Строка3); 1042 | 1043 | // Создаем идентичную копию 1044 | Строка1Копия = Новый Массив; 1045 | Строка1Копия.Добавить(1); 1046 | Строка1Копия.Добавить(2); 1047 | Строка1Копия.Добавить(3); 1048 | 1049 | Строка2Копия = Новый Массив; 1050 | Строка2Копия.Добавить(4); 1051 | Строка2Копия.Добавить(5); 1052 | Строка2Копия.Добавить(6); 1053 | 1054 | Строка3Копия = Новый Массив; 1055 | Строка3Копия.Добавить(7); 1056 | Строка3Копия.Добавить(8); 1057 | Строка3Копия.Добавить(9); 1058 | 1059 | ФактическоеЗначение = Новый Массив; 1060 | ФактическоеЗначение.Добавить(Строка1Копия); 1061 | ФактическоеЗначение.Добавить(Строка2Копия); 1062 | ФактическоеЗначение.Добавить(Строка3Копия); 1063 | 1064 | // Act & Assert 1065 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 1066 | КонецПроцедуры 1067 | 1068 | &Тест 1069 | Процедура ТестДолжен_Проверить_НеИдентичностьМногомерныхМассивовСОшибкой() Экспорт 1070 | // Arrange - многомерные массивы с ошибкой в одном элементе 1071 | Строка1 = Новый Массив; 1072 | Строка1.Добавить(1); 1073 | Строка1.Добавить(2); 1074 | Строка1.Добавить(3); 1075 | 1076 | Строка2 = Новый Массив; 1077 | Строка2.Добавить(4); 1078 | Строка2.Добавить(5); 1079 | Строка2.Добавить(6); 1080 | 1081 | ОжидаемоеЗначение = Новый Массив; 1082 | ОжидаемоеЗначение.Добавить(Строка1); 1083 | ОжидаемоеЗначение.Добавить(Строка2); 1084 | 1085 | // Создаем копию с ошибкой 1086 | Строка1СОшибкой = Новый Массив; 1087 | Строка1СОшибкой.Добавить(1); 1088 | Строка1СОшибкой.Добавить(999); // Ошибка! 1089 | Строка1СОшибкой.Добавить(3); 1090 | 1091 | Строка2Копия = Новый Массив; 1092 | Строка2Копия.Добавить(4); 1093 | Строка2Копия.Добавить(5); 1094 | Строка2Копия.Добавить(6); 1095 | 1096 | ФактическоеЗначение = Новый Массив; 1097 | ФактическоеЗначение.Добавить(Строка1СОшибкой); 1098 | ФактическоеЗначение.Добавить(Строка2Копия); 1099 | 1100 | // Act & Assert 1101 | Ожидаем.Что(ФактическоеЗначение).Не_().Идентично(ОжидаемоеЗначение); 1102 | КонецПроцедуры 1103 | 1104 | &Тест 1105 | Процедура ТестДолжен_Проверить_ИдентичностьСоответствийСМассивамиКлючей() Экспорт 1106 | // Arrange - соответствия с массивами в качестве ключей и значений 1107 | МассивКлюч1 = Новый Массив; 1108 | МассивКлюч1.Добавить("ключ"); 1109 | МассивКлюч1.Добавить(1); 1110 | 1111 | МассивЗначение1 = Новый Массив; 1112 | МассивЗначение1.Добавить("значение"); 1113 | МассивЗначение1.Добавить(2); 1114 | 1115 | ОжидаемоеЗначение = Новый Соответствие; 1116 | ОжидаемоеЗначение.Вставить("ПростойКлюч", МассивЗначение1); 1117 | ОжидаемоеЗначение.Вставить("ДругойКлюч", "Простое значение"); 1118 | 1119 | // Создаем идентичную копию 1120 | МассивЗначение1Копия = Новый Массив; 1121 | МассивЗначение1Копия.Добавить("значение"); 1122 | МассивЗначение1Копия.Добавить(2); 1123 | 1124 | ФактическоеЗначение = Новый Соответствие; 1125 | ФактическоеЗначение.Вставить("ПростойКлюч", МассивЗначение1Копия); 1126 | ФактическоеЗначение.Вставить("ДругойКлюч", "Простое значение"); 1127 | 1128 | // Act & Assert 1129 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 1130 | КонецПроцедуры 1131 | 1132 | &Тест 1133 | Процедура ТестДолжен_Проверить_ИдентичностьКомбинированныхКоллекций() Экспорт 1134 | // Arrange - структура, содержащая массив соответствий 1135 | Соответствие1 = Новый Соответствие; 1136 | Соответствие1.Вставить("ID", 1); 1137 | Соответствие1.Вставить("Название", "Первый элемент"); 1138 | 1139 | Соответствие2 = Новый Соответствие; 1140 | Соответствие2.Вставить("ID", 2); 1141 | Соответствие2.Вставить("Название", "Второй элемент"); 1142 | 1143 | МассивСоответствий = Новый Массив; 1144 | МассивСоответствий.Добавить(Соответствие1); 1145 | МассивСоответствий.Добавить(Соответствие2); 1146 | 1147 | ВложеннаяСтруктура = Новый Структура; 1148 | ВложеннаяСтруктура.Вставить("Элементы", МассивСоответствий); 1149 | ВложеннаяСтруктура.Вставить("Счетчик", МассивСоответствий.Количество()); 1150 | 1151 | ОжидаемоеЗначение = Новый Соответствие; 1152 | ОжидаемоеЗначение.Вставить("Данные", ВложеннаяСтруктура); 1153 | ОжидаемоеЗначение.Вставить("Статус", "Готов"); 1154 | 1155 | // Создаем идентичную копию 1156 | Соответствие1Копия = Новый Соответствие; 1157 | Соответствие1Копия.Вставить("ID", 1); 1158 | Соответствие1Копия.Вставить("Название", "Первый элемент"); 1159 | 1160 | Соответствие2Копия = Новый Соответствие; 1161 | Соответствие2Копия.Вставить("ID", 2); 1162 | Соответствие2Копия.Вставить("Название", "Второй элемент"); 1163 | 1164 | МассивСоответствийКопия = Новый Массив; 1165 | МассивСоответствийКопия.Добавить(Соответствие1Копия); 1166 | МассивСоответствийКопия.Добавить(Соответствие2Копия); 1167 | 1168 | ВложеннаяСтруктураКопия = Новый Структура; 1169 | ВложеннаяСтруктураКопия.Вставить("Элементы", МассивСоответствийКопия); 1170 | ВложеннаяСтруктураКопия.Вставить("Счетчик", МассивСоответствийКопия.Количество()); 1171 | 1172 | ФактическоеЗначение = Новый Соответствие; 1173 | ФактическоеЗначение.Вставить("Данные", ВложеннаяСтруктураКопия); 1174 | ФактическоеЗначение.Вставить("Статус", "Готов"); 1175 | 1176 | // Act & Assert 1177 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 1178 | КонецПроцедуры 1179 | 1180 | &Тест 1181 | Процедура ТестДолжен_Проверить_ПустыхВложенныхКоллекций() Экспорт 1182 | // Arrange - структуры с пустыми вложенными коллекциями 1183 | ПустойМассив = Новый Массив; 1184 | ПустаяСтруктура = Новый Структура; 1185 | ПустоеСоответствие = Новый Соответствие; 1186 | 1187 | ОжидаемоеЗначение = Новый Структура; 1188 | ОжидаемоеЗначение.Вставить("ПустойМассив", ПустойМассив); 1189 | ОжидаемоеЗначение.Вставить("ПустаяСтруктура", ПустаяСтруктура); 1190 | ОжидаемоеЗначение.Вставить("ПустоеСоответствие", ПустоеСоответствие); 1191 | 1192 | // Создаем копии пустых коллекций 1193 | ПустойМассивКопия = Новый Массив; 1194 | ПустаяСтруктураКопия = Новый Структура; 1195 | ПустоеСоответствиеКопия = Новый Соответствие; 1196 | 1197 | ФактическоеЗначение = Новый Структура; 1198 | ФактическоеЗначение.Вставить("ПустойМассив", ПустойМассивКопия); 1199 | ФактическоеЗначение.Вставить("ПустаяСтруктура", ПустаяСтруктураКопия); 1200 | ФактическоеЗначение.Вставить("ПустоеСоответствие", ПустоеСоответствиеКопия); 1201 | 1202 | // Act & Assert 1203 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 1204 | КонецПроцедуры 1205 | 1206 | &Тест 1207 | Процедура ТестДолжен_Проверить_НеИдентичностьПустойИНепустойКоллекции() Экспорт 1208 | // Arrange - сравниваем пустую и непустую коллекции 1209 | ПустойМассив = Новый Массив; 1210 | НепустойМассив = Новый Массив; 1211 | НепустойМассив.Добавить("элемент"); 1212 | 1213 | ОжидаемоеЗначение = Новый Структура; 1214 | ОжидаемоеЗначение.Вставить("Массив", ПустойМассив); 1215 | 1216 | ФактическоеЗначение = Новый Структура; 1217 | ФактическоеЗначение.Вставить("Массив", НепустойМассив); 1218 | 1219 | // Act & Assert 1220 | Ожидаем.Что(ФактическоеЗначение).Не_().Идентично(ОжидаемоеЗначение); 1221 | КонецПроцедуры 1222 | 1223 | &Тест 1224 | Процедура ТестДолжен_Проверить_ИдентичностьСпециальныхДат() Экспорт 1225 | // Arrange - тестируем различные форматы дат 1226 | ОжидаемоеЗначение = Новый Структура; 1227 | ОжидаемоеЗначение.Вставить("ПустаяДата", '00010101000000'); 1228 | ОжидаемоеЗначение.Вставить("НовыйГод", '20250101000000'); 1229 | ОжидаемоеЗначение.Вставить("СВременем", '20250109142530'); 1230 | ОжидаемоеЗначение.Вставить("ПолночьТочно", '20250109000000'); 1231 | 1232 | ФактическоеЗначение = Новый Структура; 1233 | ФактическоеЗначение.Вставить("ПустаяДата", '00010101000000'); 1234 | ФактическоеЗначение.Вставить("НовыйГод", '20250101000000'); 1235 | ФактическоеЗначение.Вставить("СВременем", '20250109142530'); 1236 | ФактическоеЗначение.Вставить("ПолночьТочно", '20250109000000'); 1237 | 1238 | // Act & Assert 1239 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 1240 | КонецПроцедуры 1241 | 1242 | &Тест 1243 | Процедура ТестДолжен_Проверить_НеИдентичностьДатСРазницейВСекунду() Экспорт 1244 | // Arrange - даты, отличающиеся на секунду 1245 | ОжидаемоеЗначение = '20250109142530'; // 14:25:30 1246 | ФактическоеЗначение = '20250109142531'; // 14:25:31 1247 | 1248 | // Act & Assert 1249 | Ожидаем.Что(ФактическоеЗначение).Не_().Идентично(ОжидаемоеЗначение); 1250 | КонецПроцедуры 1251 | 1252 | &Тест 1253 | Процедура ТестДолжен_Проверить_ИдентичностьБулевыхВМассивах() Экспорт 1254 | // Arrange - массивы с различными булевыми значениями 1255 | ОжидаемоеЗначение = Новый Массив; 1256 | ОжидаемоеЗначение.Добавить(Истина); 1257 | ОжидаемоеЗначение.Добавить(Ложь); 1258 | ОжидаемоеЗначение.Добавить(Истина); 1259 | ОжидаемоеЗначение.Добавить(Ложь); 1260 | 1261 | ФактическоеЗначение = Новый Массив; 1262 | ФактическоеЗначение.Добавить(Истина); 1263 | ФактическоеЗначение.Добавить(Ложь); 1264 | ФактическоеЗначение.Добавить(Истина); 1265 | ФактическоеЗначение.Добавить(Ложь); 1266 | 1267 | // Act & Assert 1268 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 1269 | КонецПроцедуры 1270 | 1271 | &Тест 1272 | Процедура ТестДолжен_Проверить_НеИдентичностьБулевыхВМассивах() Экспорт 1273 | // Arrange - массивы с отличающимися булевыми значениями 1274 | ОжидаемоеЗначение = Новый Массив; 1275 | ОжидаемоеЗначение.Добавить(Истина); 1276 | ОжидаемоеЗначение.Добавить(Ложь); 1277 | ОжидаемоеЗначение.Добавить(Истина); 1278 | 1279 | ФактическоеЗначение = Новый Массив; 1280 | ФактическоеЗначение.Добавить(Истина); 1281 | ФактическоеЗначение.Добавить(Истина); // Отличается! 1282 | ФактическоеЗначение.Добавить(Истина); 1283 | 1284 | // Act & Assert 1285 | Ожидаем.Что(ФактическоеЗначение).Не_().Идентично(ОжидаемоеЗначение); 1286 | КонецПроцедуры 1287 | 1288 | &Тест 1289 | Процедура ТестДолжен_Проверить_ИдентичностьСтрокСПробелами() Экспорт 1290 | // Arrange - строки с различными пробельными символами 1291 | ОжидаемоеЗначение = Новый Структура; 1292 | ОжидаемоеЗначение.Вставить("СПробелами", " Строка с пробелами "); 1293 | ОжидаемоеЗначение.Вставить("БезПробелов", "СтрокаБезПробелов"); 1294 | ОжидаемоеЗначение.Вставить("ТолькоПробелы", " "); 1295 | ОжидаемоеЗначение.Вставить("ПустаяСтрока", ""); 1296 | 1297 | ФактическоеЗначение = Новый Структура; 1298 | ФактическоеЗначение.Вставить("СПробелами", " Строка с пробелами "); 1299 | ФактическоеЗначение.Вставить("БезПробелов", "СтрокаБезПробелов"); 1300 | ФактическоеЗначение.Вставить("ТолькоПробелы", " "); 1301 | ФактическоеЗначение.Вставить("ПустаяСтрока", ""); 1302 | 1303 | // Act & Assert 1304 | Ожидаем.Что(ФактическоеЗначение).Идентично(ОжидаемоеЗначение); 1305 | КонецПроцедуры 1306 | 1307 | &Тест 1308 | Процедура ТестДолжен_Проверить_НеИдентичностьСтрокСРазнымиПробелами() Экспорт 1309 | // Arrange - строки с разным количеством пробелов 1310 | ОжидаемоеЗначение = " два пробела "; 1311 | ФактическоеЗначение = " один пробел "; 1312 | 1313 | // Act & Assert 1314 | Ожидаем.Что(ФактическоеЗначение).Не_().Идентично(ОжидаемоеЗначение); 1315 | КонецПроцедуры 1316 | --------------------------------------------------------------------------------