ObjectModule.bsl

Перем РезультатыСравненияТаблиц Экспорт;
Перем СтатусыРезультатаТестирования Экспорт;
Перем ПараметрыОтчетаУФ;
Перем ОтчетВРежимеУФ;
Перем ЭтоLinux;
Перем РазницаВМилисекундахМеждуЮниксИНачалЭпохи;

Перем КешРежимСовместимости;
Перем КешВерсияРежимСовместимости;

Функция ПолучитьВерсиюОбработки(ДобавлятьНазвание = Истина, ТолькоЦифры = Ложь) Экспорт
  Версия = "6.9.5";
	Если ТолькоЦифры Тогда
		Возврат Версия;
	КонецЕсли;

	Если ДобавлятьНазвание Тогда
		Возврат "vanessa-add ver. " + Версия;
	КонецЕсли;

	Возврат "ver " + Версия;
КонецФункции

// { Plugins
// портировано из xUnitFor1C 4.1.1.0

Функция ТипыПлагинов()
	Результат = Новый Структура;
	Результат.Вставить("Загрузчик", "Загрузчик");
	Результат.Вставить("Утилита", "Утилита");
	Результат.Вставить("ГенераторОтчета", "ГенераторОтчета");

	Возврат Новый ФиксированнаяСтруктура(Результат);
КонецФункции

Функция Плагин(Знач Идентификатор) Экспорт

	ИдентификаторПлагинаСПрефиксомПодсистемы = Идентификатор;
	ИдентификаторПлагинаБезПрефиксаПодсистемы = Идентификатор;
	Плагин = Плагины[ИдентификаторПлагинаБезПрефиксаПодсистемы];
	Если ТипЗнч(Плагин) = Тип("Строка") Тогда
		Плагин = СоздатьОбъектПлагина(Плагин);
	КонецЕсли;

	Возврат Плагин;

КонецФункции

Функция ПолучитьОписанияПлагиновПоТипу(Знач ТипПлагина) Экспорт
	Результат = Новый Массив;
	Для каждого КлючЗначение Из Плагины Цикл
		Плагин = Плагин(КлючЗначение.Ключ);
		Плагин.Инициализация(ЭтотОбъект);
		ОписаниеПлагина = Плагин.ОписаниеПлагина(ЭтотОбъект, ТипыПлагинов);
		Если ОписаниеПлагина = Неопределено Тогда
			Продолжить;
		КонецЕсли;
		Если ОписаниеПлагина.Тип = ТипПлагина Тогда
			Результат.Добавить(ОписаниеПлагина);
		КонецЕсли;
	КонецЦикла;

	Возврат Результат;
КонецФункции

Функция СоздатьОбъектПлагина(Идентификатор, ВстроенаВКонфигурацию = Ложь, ЭтоОтчет = Ложь) Экспорт

	ОбъектПлагина = Неопределено;

	Если ОбъектПлагина = Неопределено Тогда
		Если ЭтоОтчет = Истина Тогда
			ОбъектПлагина = ВнешниеОтчеты.Создать(Идентификатор, Ложь);
		Иначе
			ОбъектПлагина = ВнешниеОбработки.Создать(Идентификатор, Ложь);
		КонецЕсли;
	КонецЕсли;

	Возврат ОбъектПлагина;

КонецФункции

// } Plugins

Функция Транслит(Стр) Экспорт
    Рез = СокрЛП(Стр);
    Рез = СтрЗаменить(Рез,"а","a");
    Рез = СтрЗаменить(Рез,"б","b");
    Рез = СтрЗаменить(Рез,"в","v");
    Рез = СтрЗаменить(Рез,"г","g");
    Рез = СтрЗаменить(Рез,"д","d");
    Рез = СтрЗаменить(Рез,"е","e");
    Рез = СтрЗаменить(Рез,"ё","e");
    Рез = СтрЗаменить(Рез,"ж","zh");
    Рез = СтрЗаменить(Рез,"з","z");
    Рез = СтрЗаменить(Рез,"и","i");
    Рез = СтрЗаменить(Рез,"к","k");
    Рез = СтрЗаменить(Рез,"л","l");
    Рез = СтрЗаменить(Рез,"м","m");
    Рез = СтрЗаменить(Рез,"н","n");
    Рез = СтрЗаменить(Рез,"о","o");
    Рез = СтрЗаменить(Рез,"п","p");
    Рез = СтрЗаменить(Рез,"р","r");
    Рез = СтрЗаменить(Рез,"с","s");
    Рез = СтрЗаменить(Рез,"т","t");
    Рез = СтрЗаменить(Рез,"у","u");
    Рез = СтрЗаменить(Рез,"ф","f");
    Рез = СтрЗаменить(Рез,"х","h");
    Рез = СтрЗаменить(Рез,"ч","ch");
    Рез = СтрЗаменить(Рез,"ш","sh");
    Рез = СтрЗаменить(Рез,"щ","sch");
    Рез = СтрЗаменить(Рез,"ъ","");
    Рез = СтрЗаменить(Рез,"ь","");
    Рез = СтрЗаменить(Рез,"э","e");
    Рез = СтрЗаменить(Рез,"ю","yu");
    Рез = СтрЗаменить(Рез,"й","i");
    Рез = СтрЗаменить(Рез,"ц","c");
    Рез = СтрЗаменить(Рез,"я","ya");
    Рез = СтрЗаменить(Рез,"ы","i");
    Рез = СтрЗаменить(Рез,"А","A");
    Рез = СтрЗаменить(Рез,"Б","B");
    Рез = СтрЗаменить(Рез,"В","V");
    Рез = СтрЗаменить(Рез,"Г","G");
    Рез = СтрЗаменить(Рез,"Д","D");
    Рез = СтрЗаменить(Рез,"Е","E");
    Рез = СтрЗаменить(Рез,"Ё","E");
    Рез = СтрЗаменить(Рез,"Ж","ZH");
    Рез = СтрЗаменить(Рез,"З","Z");
    Рез = СтрЗаменить(Рез,"И","I");
    Рез = СтрЗаменить(Рез,"К","K");
    Рез = СтрЗаменить(Рез,"Л","L");
    Рез = СтрЗаменить(Рез,"М","M");
    Рез = СтрЗаменить(Рез,"Н","N");
    Рез = СтрЗаменить(Рез,"О","O");
    Рез = СтрЗаменить(Рез,"П","P");
    Рез = СтрЗаменить(Рез,"Р","R");
    Рез = СтрЗаменить(Рез,"С","S");
    Рез = СтрЗаменить(Рез,"Т","T");
    Рез = СтрЗаменить(Рез,"У","U");
    Рез = СтрЗаменить(Рез,"Ф","F");
    Рез = СтрЗаменить(Рез,"Х","H");
    Рез = СтрЗаменить(Рез,"Ч","CH");
    Рез = СтрЗаменить(Рез,"Ш","SH");
    Рез = СтрЗаменить(Рез,"Щ","SCH");
    Рез = СтрЗаменить(Рез,"Ъ","");
    Рез = СтрЗаменить(Рез,"Ь","");
    Рез = СтрЗаменить(Рез,"Ы","I");
    Рез = СтрЗаменить(Рез,"Ц","C");
    Рез = СтрЗаменить(Рез,"Э","E");
    Рез = СтрЗаменить(Рез,"Ю","YU");
    Рез = СтрЗаменить(Рез,"Я","YA");
    Рез = СтрЗаменить(Рез,"Й","I");
    Возврат(Рез);
КонецФункции

Процедура СделатьСообщение(Знач Сообщение, ТипСообщения = "Информация") Экспорт

	ТипСообщения = ?(ТипСообщения = "Информация", СтатусСообщения.Обычное, СтатусСообщения.ОченьВажное);

	Если ДелатьСообщенияТранслитом Тогда
		Сообщение = Транслит(Сообщение);
	КонецЕсли;

	Сообщить(Строка(ТекущаяДата()) + " " + Сообщение, ТипСообщения);
КонецПроцедуры

Процедура Отладка(Знач Сообщение) Экспорт
	Если DebugLog Тогда
		СделатьСообщение(Сообщение);
	КонецЕсли;
КонецПроцедуры

Функция ДополнитьСлешВПуть(Знач Каталог) Экспорт
	разделитель = "\";

	Если ЭтоLinux Тогда
		разделитель = "/";
	КонецЕсли;

	Если Найти(Прав(Каталог, 1), "\/") > 0 Тогда
		Каталог = Лев(Каталог,СтрДлина(Каталог)-1);
	КонецЕсли;

	Если Прав(Каталог, 1) <> разделитель Тогда
		Каталог = Каталог + разделитель;
	КонецЕсли;

	Возврат Каталог;

КонецФункции

//{Отчет Allure

Процедура ЗаписатьСтатусВШагИлиСценарий(ОбъектДляЗаписи,Статус)
	Если Статус = "Success" Тогда
		ОбъектДляЗаписи.status = "passed";
	ИначеЕсли Статус = "Pending" Тогда
		ОбъектДляЗаписи.status = "pending";
	ИначеЕсли Статус = "Failed" Тогда
		ОбъектДляЗаписи.status = "failed";
	ИначеЕсли Статус = "Skipped" Тогда
		ОбъектДляЗаписи.status = "skipped";
	Иначе
		ОбъектДляЗаписи.status = "skipped";
	КонецЕсли;

КонецПроцедуры

Процедура ДобавитьПрефиксAllureВСтроку(Стр)
	Стр = СтрЗаменить(Стр,"<test-suite-result","<ns2:test-suite");
	Стр = СтрЗаменить(Стр,"</test-suite-result>","</ns2:test-suite>");
	Стр = СтрЗаменить(Стр,"xmlns=""urn:model.allure.qatools.yandex.ru""","xmlns:ns2=""urn:model.allure.qatools.yandex.ru""");
КонецПроцедуры

Процедура ДобавитьМетку(Фабрика,СписокМеток,name,value, СписокПереопределяемый = Неопределено)
	Если СписокПереопределяемый <> Неопределено И ТипЗнч(СписокПереопределяемый) = Тип("СписокЗначений") Тогда
		Если СписокПереопределяемый.НайтиПоЗначению(name) <> Неопределено Тогда
			Возврат;
		КонецЕсли;
	КонецЕсли;

	Типlabel    = Фабрика.Тип("urn:model.allure.qatools.yandex.ru", "label");
	Метка       = Фабрика.Создать(Типlabel);
	Метка.name  = name;
	Метка.value = value;

	СписокМеток.label.Добавить(Метка);
КонецПроцедуры

Функция УбратьСимволыДляКорректногоОтчетаAllure(Знач Стр)
	Стр = СтрЗаменить(Стр,".","_");
	Возврат Стр;
КонецФункции

Функция ПолучитьПрефиксИмениСценария()
	Если ЗначениеЗаполнено(ИмяТекущейСборки) Тогда
		Возврат "(" + УбратьСимволыДляКорректногоОтчетаAllure(ИмяТекущейСборки) + ") ";
	КонецЕсли;

	Возврат "";
КонецФункции

Процедура ОбойтиДеревоДляОтчетаАллюр(Дерево,Фабрика,ТекущаяФича = Неопределено,СписокСценариев = Неопределено,СписокШагов = Неопределено)
	Для каждого СтрСтроки Из Дерево.Строки Цикл
		Если      СтрСтроки.Тип = "Фича" Тогда

			GUID             = Новый УникальныйИдентификатор();
			РеальноеИмяФайла = "" + GUID +"-testsuite.xml";
			ИмяФайлаXML      = ДополнитьСлешВПуть(КаталогOutputAllure) + РеальноеИмяФайла;

			Если ОтчетВРежимеУФ Тогда
				СтруткутаДляФайлаXML = Новый Структура;
				СтруткутаДляФайлаXML.Вставить("РеальноеИмяФайла",РеальноеИмяФайла);

				ИмяФайлаXML = ПолучитьИмяВременногоФайла("xml");
			КонецЕсли;

			ЗТ = Новый ЗаписьТекста(ИмяФайлаXML, КодировкаТекста.ANSI);
			ЗТ.Закрыть();

			ВременныйФайлXML = ПолучитьИмяВременногоФайла("xml");
			ЗаписьXML = Новый ЗаписьXML;

			ЗаписьXML.ОткрытьФайл(ВременныйФайлXML);
			ЗаписьXML.ЗаписатьОбъявлениеXML();

			ТипTestSuiteResult = Фабрика.Тип("urn:model.allure.qatools.yandex.ru", "test-suite-result");
			ТекущаяФича        = Фабрика.Создать(ТипTestSuiteResult);
			ТекущаяФича.name   = СтрСтроки.Имя;

			ТипTestCasesResult = Фабрика.Тип("urn:model.allure.qatools.yandex.ru", "test-cases-result");
			СписокСценариев    = Фабрика.Создать(ТипTestCasesResult);

			ОбойтиДеревоДляОтчетаАллюр(СтрСтроки,Фабрика,ТекущаяФича,СписокСценариев,СписокШагов);

			ТекущаяФича.test_cases = СписокСценариев;

			Типlabels   = Фабрика.Тип("urn:model.allure.qatools.yandex.ru", "labels");
			СписокМеток = Фабрика.Создать(Типlabels);

			ДобавитьМетку(Фабрика,СписокМеток,"feature",СтрСтроки.Имя);
			ДобавитьМетку(Фабрика,СписокМеток,"framework","vanessa-add");
			ДобавитьМетку(Фабрика,СписокМеток,"language","1С");

			ТекущаяФича.labels = СписокМеток;

			Фабрика.ЗаписатьXML(ЗаписьXML, ТекущаяФича);
			ЗаписьXML.Закрыть();

			//делаем запись без BOM и немного преобразуем строки xml
			ЗТ = Новый ЗаписьТекста(ИмяФайлаXML,,, Истина);
			Текст = Новый ЧтениеТекста;
			Текст.Открыть(ВременныйФайлXML,"UTF-8");

			Пока Истина Цикл
				Стр = Текст.ПрочитатьСтроку();
				Если Стр = Неопределено Тогда
					Прервать;
				КонецЕсли;
				ДобавитьПрефиксAllureВСтроку(Стр);

				ЗТ.ЗаписатьСтроку(Стр);
			КонецЦикла;
			ЗТ.Закрыть();
			Текст.Закрыть();

			Если ОтчетВРежимеУФ Тогда
				ДвоичныеДанные = Новый ДвоичныеДанные(ИмяФайлаXML);
				СтруткутаДляФайлаXML.Вставить("ФайлXMLДвоичныеДанные",ДвоичныеДанные);
				ПараметрыОтчетаУФ.МассивXMLОтчетаAllure.Добавить(СтруткутаДляФайлаXML);

				УдалитьФайлы(ИмяФайлаXML);
			Иначе
				СделатьСообщение("Файл отчета Allure-report (" + ИмяФайлаXML + ") записан.");
			КонецЕсли;

		ИначеЕсли (СтрСтроки.Тип = "Сценарий") или (СтрСтроки.Тип = "Пример") Тогда
			Если (СтрСтроки.ДопТип = "Контекст") Тогда
				//его не надо добавлять в отчет, т.к. этот сценарий включается в каждый сценарий

			ИначеЕсли (СтрСтроки.ДопТип = "СтруктураСценария") или (СтрСтроки.Строки.Количество() = 0) Тогда
				//его не надо добавлять в отчет, т.к. этот сценарий явно не выполняется
				ОбойтиДеревоДляОтчетаАллюр(СтрСтроки,Фабрика,ТекущаяФича,СписокСценариев,СписокШагов);
			Иначе

				РезультатПрохожденияТестовСценария = ПолучитьРезультатПрохожденияТестовСценария(СтрСтроки);

				Если РезультатПрохожденияТестовСценария = Неопределено Тогда
					Продолжить;
				КонецЕсли;

				ТипTestCaseResult = Фабрика.Тип("urn:model.allure.qatools.yandex.ru", "test-case-result");
				Сценарий          = Фабрика.Создать(ТипTestCaseResult);

				ПрефиксИмениСценария = "";
				Если ДобавлятьКИмениСценарияУсловияВыгрузки Тогда
					ПрефиксИмениСценария = ПолучитьПрефиксИмениСценария();
				КонецЕсли;

				Если СтрСтроки.Тип = "Пример" Тогда
					Сценарий.name     = ПрефиксИмениСценария + СтрСтроки.Родитель.Родитель.Имя + " №" + (СтрСтроки.Родитель.Строки.Индекс(СтрСтроки));
				Иначе
					Сценарий.name     = ПрефиксИмениСценария + СтрСтроки.Имя;
				КонецЕсли;

				Сценарий.start = РезультатПрохожденияТестовСценария.ВремяНачала - РазницаВМилисекундахМеждуЮниксИНачалЭпохи;
				Сценарий.stop  = РезультатПрохожденияТестовСценария.ВремяОкончания - РазницаВМилисекундахМеждуЮниксИНачалЭпохи;

				ТипSteps    = Фабрика.Тип("urn:model.allure.qatools.yandex.ru", "steps");
				СписокШагов = Фабрика.Создать(ТипSteps);

				Если СтрСтроки.ДопТип = "СтруктураСценария" Тогда
					ОбойтиДеревоДляОтчетаАллюр(СтрСтроки,Фабрика,ТекущаяФича,СписокСценариев,СписокШагов);
				Иначе
					Для каждого СтрРезультатПрохожденияТестовШагов Из РезультатПрохожденияТестовСценария.РезультатПрохожденияТестовШагов Цикл
						ТипStep   = Фабрика.Тип("urn:model.allure.qatools.yandex.ru", "step");
						Шаг       = Фабрика.Создать(ТипStep);
						Шаг.name  = СтрРезультатПрохожденияТестовШагов.Имя;
						Шаг.title = СтрРезультатПрохожденияТестовШагов.Имя;

						Если СтрРезультатПрохожденияТестовШагов.ВремяНачала <> Неопределено Тогда
							Шаг.start = СтрРезультатПрохожденияТестовШагов.ВремяНачала - РазницаВМилисекундахМеждуЮниксИНачалЭпохи;;
							Шаг.stop  = СтрРезультатПрохожденияТестовШагов.ВремяОкончания - РазницаВМилисекундахМеждуЮниксИНачалЭпохи;;
						КонецЕсли;

						ЗаписатьСтатусВШагИлиСценарий(Шаг,СтрРезультатПрохожденияТестовШагов.Статус);

						СписокШагов.step.Добавить(Шаг);
					КонецЦикла;
				КонецЕсли;

				ЗаписатьСтатусВШагИлиСценарий(Сценарий,СтрСтроки.Статус);
				Если (СтрСтроки.Статус = "Failed") или (СтрСтроки.Статус = "Pending") Тогда
					ТипFailure            = Фабрика.Тип("urn:model.allure.qatools.yandex.ru", "failure");
					ОбъектFailure         = Фабрика.Создать(ТипFailure);
					ОбъектFailure.message = РезультатПрохожденияТестовСценария.ОписаниеОшибки;

					Сценарий.failure = ОбъектFailure;
				КонецЕсли;
				Сценарий.steps = СписокШагов;

				Если РезультатПрохожденияТестовСценария.Свойство("МассивСкриншотов") Тогда
					//значит есть скриншоты

					Типattachments    = Фабрика.Тип("urn:model.allure.qatools.yandex.ru", "attachments");
					Списокattachments = Фабрика.Создать(Типattachments);

					Для каждого СтруктураСкриншот Из РезультатПрохожденияТестовСценария.МассивСкриншотов Цикл
						Типattachment  = Фабрика.Тип("urn:model.allure.qatools.yandex.ru", "attachment");
						attachment      = Фабрика.Создать(Типattachment);

						attachment.title  = "screenshot";
						attachment.source = СтруктураСкриншот.ИмяФайла;

						Списокattachments.attachment.Добавить(attachment);
					КонецЦикла;
					Сценарий.attachments = Списокattachments;
				КонецЕсли;

				Типlabels   = Фабрика.Тип("urn:model.allure.qatools.yandex.ru", "labels");
				СписокМеток = Фабрика.Создать(Типlabels);
				ДобавитьМетку(Фабрика,СписокМеток,"story",СтрСтроки.Имя);
				Сценарий.labels = СписокМеток;

				СписокСценариев.test_case.Добавить(Сценарий);
			КонецЕсли;
		ИначеЕсли СтрСтроки.Тип = "Шаг" Тогда
			Если СтрСтроки.Родитель.ДопТип = "СтруктураСценария" Тогда
				//его не надо добавлять в отчет, т.к. этот сценарий явно не выполняется
				ОбойтиДеревоДляОтчетаАллюр(СтрСтроки,Фабрика,ТекущаяФича,СписокСценариев,СписокШагов);
			КонецЕсли;
		Иначе
			ОбойтиДеревоДляОтчетаАллюр(СтрСтроки,Фабрика,ТекущаяФича,СписокСценариев,СписокШагов);
		КонецЕсли;
	КонецЦикла;
КонецПроцедуры

Процедура СформироватьОтчетАллюр(Знач СтруктураОФ) Экспорт
	Перем СтарыйКаталог, ИмяФайла;

	СтарыйКаталог = КаталогOutputAllure;

	ОтчетВРежимеУФ = Ложь;



	Если СтруктураОФ.Свойство("ЭтоОФ") Тогда
		ИмяФайлаСхемы     = КаталогИнструментов + "/vendor/allure-framework/allure.xsd";

		ОтчетВРежимеУФ = Ложь;

		Файл = Новый Файл(КаталогOutputAllure);
		Если Не Файл.Существует() Тогда
			СделатьСообщение("Не могу сфомировать отчет Allure. Не существует каталог для вывода отчета.");
			Возврат;
		КонецЕсли;

		Фабрика      = СоздатьФабрикуXDTO(ИмяФайлаСхемы);

		КаталогOutputAllure = ДополнитьСлешВПуть(КаталогOutputAllure);

		ОбойтиДеревоДляОтчетаАллюр(ДеревоТестов, Фабрика);

		КаталогOutputAllure = СтарыйКаталог;

	Иначе

		Аллюр2 = Плагин("Аллюр2Отчет");
		Аллюр2.СформироватьОтчетАллюр2(СтруктураОФ, ДеревоТестов, ИмяТекущейСборки,
			ДобавлятьКИмениСценарияУсловияВыгрузки);
	КонецЕсли;

КонецПроцедуры

//}

//{Отчет jUnit

Функция Определить_classname(ДопПараметры)
	classname = ДопПараметры.ТекущаяФичаИмя;

	Если ДобавлятьКИмениСценарияУсловияВыгрузки Тогда
		Если ДопПараметры.ТекУровеньКаталога >= 2 Тогда
			classname = ДопПараметры.УровниКаталогов[0] + "." + ДопПараметры.ТекущаяФичаИмя;
		КонецЕсли;
	Иначе
		Если ДопПараметры.ТекУровеньКаталога >= 2 Тогда
			classname = ДопПараметры.УровниКаталогов[0] + "." + ДопПараметры.ТекущаяФичаИмя;
		КонецЕсли;
	КонецЕсли;

	Возврат classname;
КонецФункции

Процедура ОбойтиДеревоДляОтчетаjUnit(Дерево, ЗаписьXML, ДопПараметры,ДанныеФичи = Неопределено)
	Для каждого СтрСтроки Из Дерево.Строки Цикл
		Если      СтрСтроки.Тип = "Фича" Тогда

			ДопПараметры.Вставить("ТекущаяФичаИмя",СтрСтроки.Имя);

			МассивСценариев = Новый Массив;

			ДанныеФичи = Новый Структура;
			ДанныеФичи.Вставить("МассивСценариев",МассивСценариев);
			ДанныеФичи.Вставить("errors",0);
			ДанныеФичи.Вставить("skipped",0);
			ДанныеФичи.Вставить("tests",0);
			ДанныеФичи.Вставить("failures",0);
			ДанныеФичи.Вставить("time",0);

			ОбойтиДеревоДляОтчетаjUnit(СтрСтроки,ЗаписьXML,ДопПараметры,ДанныеФичи);

			ПрефиксИмениСценария = "";
			Если ДобавлятьКИмениСценарияУсловияВыгрузки Тогда
				ПрефиксИмениСценария = ПолучитьПрефиксИмениСценария();
			КонецЕсли;



			ЗаписьXML.ЗаписатьНачалоЭлемента("testsuite");
			Если ДобавлятьКИмениСценарияУсловияВыгрузки Тогда
				ЗаписьXML.ЗаписатьАтрибут("name", СтрСтроки.Имя);
			Иначе
				ЗаписьXML.ЗаписатьАтрибут("name", СтрСтроки.Имя);
			КонецЕсли;



			ЗаписьXML.ЗаписатьАтрибут("errors", XMLСтрока(ДанныеФичи.errors));
			ЗаписьXML.ЗаписатьАтрибут("skipped", XMLСтрока(ДанныеФичи.skipped));
			ЗаписьXML.ЗаписатьАтрибут("tests", XMLСтрока(ДанныеФичи.tests));
			ЗаписьXML.ЗаписатьАтрибут("failures", XMLСтрока(ДанныеФичи.failures));
			ЗаписьXML.ЗаписатьАтрибут("time", XMLСтрока(ДанныеФичи.time/1000));


			Для Каждого Сценарий Из МассивСценариев Цикл
				ЗаписьXML.ЗаписатьНачалоЭлемента("testcase");

				Если ДобавлятьКИмениСценарияУсловияВыгрузки Тогда
					ЗаписьXML.ЗаписатьАтрибут("name", ПрефиксИмениСценария + Сценарий.name);
				Иначе
					ЗаписьXML.ЗаписатьАтрибут("name", Сценарий.name);
				КонецЕсли;
				ЗаписьXML.ЗаписатьАтрибут("classname", Сценарий.classname);
				ЗаписьXML.ЗаписатьАтрибут("time", XMLСтрока(Сценарий.time/1000));
				Если Сценарий.Статус = "Failed" Тогда
					ЗаписьXML.ЗаписатьНачалоЭлемента("failure");
					ЗаписьXML.ЗаписатьАтрибут("message",Сценарий.message);
					ЗаписьXML.ЗаписатьКонецЭлемента();
				ИначеЕсли Сценарий.Статус = "Pending" Тогда
					ЗаписьXML.ЗаписатьНачалоЭлемента("skipped");
					ЗаписьXML.ЗаписатьКонецЭлемента();
				КонецЕсли;

				ЗаписьXML.ЗаписатьКонецЭлемента();
			КонецЦикла;

			ЗаписьXML.ЗаписатьКонецЭлемента();

		ИначеЕсли (СтрСтроки.Тип = "Сценарий") или (СтрСтроки.Тип = "Пример") Тогда
			Если (СтрСтроки.ДопТип = "Контекст") Тогда
				//его не надо добавлять в отчет, т.к. этот сценарий включается в каждый сценарий

			ИначеЕсли (СтрСтроки.ДопТип = "СтруктураСценария") или (СтрСтроки.Строки.Количество() = 0) Тогда
				//его не надо добавлять в отчет, т.к. этот сценарий явно не выполняется
				ОбойтиДеревоДляОтчетаjUnit(СтрСтроки,ЗаписьXML,ДопПараметры,ДанныеФичи);
			Иначе

				РезультатПрохожденияТестовСценария = ПолучитьРезультатПрохожденияТестовСценария(СтрСтроки);

				Если РезультатПрохожденияТестовСценария = Неопределено Тогда
					Продолжить;
				КонецЕсли;

				Сценарий          = Новый Структура;
				ДанныеФичи.МассивСценариев.Добавить(Сценарий);


				Если СтрСтроки.Тип = "Пример" Тогда
					Сценарий.Вставить("name", СтрСтроки.Родитель.Родитель.Имя + " №" + (СтрСтроки.Родитель.Строки.Индекс(СтрСтроки)));//для структуры сценария надо вести нумерацию
				Иначе
					Сценарий.Вставить("name", СтрСтроки.Имя);
				КонецЕсли;

				classname = Определить_classname(ДопПараметры);
				Сценарий.Вставить("classname",classname);

				Сценарий.Вставить("time",РезультатПрохожденияТестовСценария.ВремяОкончания - РезультатПрохожденияТестовСценария.ВремяНачала);
				ДанныеФичи.time = ДанныеФичи.time + Сценарий.time;


				Если СтрСтроки.ДопТип = "СтруктураСценария" Тогда
					ОбойтиДеревоДляОтчетаjUnit(СтрСтроки,ЗаписьXML,ДопПараметры,ДанныеФичи);
				КонецЕсли;

				Сценарий.Вставить("Статус",СтрСтроки.Статус);

				ДанныеФичи.tests = ДанныеФичи.tests + 1;

				Если (СтрСтроки.Статус = "Failed")  Тогда
					Сценарий.Вставить("message",РезультатПрохожденияТестовСценария.ОписаниеОшибки);
					ДанныеФичи.failures = ДанныеФичи.failures + 1;
				ИначеЕсли (СтрСтроки.Статус = "Pending") Тогда
					Сценарий.Вставить("message",РезультатПрохожденияТестовСценария.ОписаниеОшибки);
					ДанныеФичи.skipped = ДанныеФичи.skipped + 1;
				КонецЕсли;
			КонецЕсли;
		ИначеЕсли СтрСтроки.Тип = "Шаг" Тогда
			Если СтрСтроки.Родитель.ДопТип = "СтруктураСценария" Тогда
				//его не надо добавлять в отчет, т.к. этот сценарий явно не выполняется
				ОбойтиДеревоДляОтчетаjUnit(СтрСтроки,ЗаписьXML,ДопПараметры,ДанныеФичи);
			КонецЕсли;
		ИначеЕсли СтрСтроки.Тип = "Каталог" Тогда

			ДопПараметры.ТекУровеньКаталога = ДопПараметры.ТекУровеньКаталога + 1;
			//Запоминаем уровни каталогов. Нас интересует только уровень 2 и 3. Т.е. если каталоги лежат как features\Core\FeatureLoad, то мы запомним только Core\FeatureLoad
			Если ДопПараметры.ТекУровеньКаталога = 2 Тогда
				ДопПараметры.УровниКаталогов[0] = СтрСтроки.Имя;
			ИначеЕсли ДопПараметры.ТекУровеньКаталога = 3 Тогда
				ДопПараметры.УровниКаталогов[1] = СтрСтроки.Имя;
			КонецЕсли;


			ОбойтиДеревоДляОтчетаjUnit(СтрСтроки,ЗаписьXML,ДопПараметры,ДанныеФичи);


			ДопПараметры.ТекУровеньКаталога = ДопПараметры.ТекУровеньКаталога - 1;
		Иначе
			ОбойтиДеревоДляОтчетаjUnit(СтрСтроки,ЗаписьXML,ДопПараметры,ДанныеФичи);
		КонецЕсли;
	КонецЦикла;
КонецПроцедуры

Процедура СформироватьОтчетjUnit(СтруктураОФ) Экспорт
	Перем СтарыйКаталог, ПутьКВременномуКаталогуНаСервере, ИмяФайла;
	СтарыйКаталог = КаталогOutputjUnit;

	ОтчетВРежимеУФ = Ложь;
	Если СтруктураОФ.ЭтоОФ Тогда
		ОтчетВРежимеУФ = Ложь;
	Иначе
		ОтчетВРежимеУФ = Истина;
		МассивXMLОтчетаjUnit = Новый Массив;
		СтруктураОФ.Вставить("МассивXMLОтчетаjUnit", МассивXMLОтчетаjUnit);


		ПараметрыОтчетаУФ    = СтруктураОФ;
	КонецЕсли;


	ВременныйXML = ПолучитьИмяВременногоФайла("xml");

	//делаем запись без BOM
	ЗТ = Новый ЗаписьТекста(ВременныйXML,"Windows-1251",,Ложь);
	ЗТ.Закрыть();

	ЗаписьXML = Новый ЗаписьXML();
	ЗаписьXML.ОткрытьФайл(ВременныйXML, "UTF-8");
	ЗаписьXML.ЗаписатьОбъявлениеXML();
	ЗаписьXML.ЗаписатьНачалоЭлемента("testsuites");


	//определим уровни иерархии для отчета
	//если был загружен каталог - тогда фичи буду браться начиная со второго уровня каталога, чтобы не тратить уровень иерархии на очевидное

	//jUnit позволяет создать три уровня иерархии для просмотра в Jenkins http://stackoverflow.com/questions/38118602/jenkins-test-result-parsing
	//т.е. может быть два уровня каталогов и третий уровень с тестами

	ДопПараметры = Новый Структура;
	ДопПараметры.Вставить("УровниКаталогов",Новый Массив);
	ДопПараметры.УровниКаталогов.Добавить("");
	ДопПараметры.УровниКаталогов.Добавить("");

	ДопПараметры.Вставить("ТекУровеньКаталога",0);
	ОбойтиДеревоДляОтчетаjUnit(ДеревоТестов, ЗаписьXML,ДопПараметры);

	ЗаписьXML.ЗаписатьКонецЭлемента();
	ЗаписьXML.Закрыть();

	ДД = Новый ДвоичныеДанные(ВременныйXML);
	СтруктураОФ.Вставить("xml",ДД);
	УдалитьФайлы(ВременныйXML);

КонецПроцедуры

//}

//{Отчет Cucumber

Функция ЭтоЦелоеЧисло(Стр)
	Для Ккк = 1 По СтрДлина(Стр) Цикл
		Символ = Сред(Стр,Ккк,1);
		Если    Символ = "0"
			Или Символ = "1"
			Или Символ = "2"
			Или Символ = "3"
			Или Символ = "4"
			Или Символ = "5"
			Или Символ = "6"
			Или Символ = "7"
			Или Символ = "8"
			Или Символ = "9"
			Тогда
			//это цифра
		Иначе
			Возврат Ложь;
		КонецЕсли;
	КонецЦикла;

	Возврат Истина;
КонецФункции

Функция ПолучитьНомерСтрокиИзПути(Стр)
	Длина = СтрДлина(Стр);
	Рез   = "";
	Для Ккк = 1 По Длина Цикл
		Символ = Сред(Стр,Длина - Ккк + 1,1);
		Если ЭтоЦелоеЧисло(Символ) Тогда
			Рез = Символ + Рез;
		Иначе
			Прервать;
		КонецЕсли;
	КонецЦикла;

	Если Рез = "" Тогда
		Рез = "0";
	КонецЕсли;

	Возврат Число(Рез);
КонецФункции

Процедура ПолучитьПервоеСлово(Знач Стр,keyword,name)
	Стр = СокрЛП(СтрЗаменить(Стр,Символы.Таб," "));
	Поз = Найти(Стр," ");
	keyword = Лев(Стр,Поз-1);
	name = СокрЛП(Сред(Стр,Поз+1));
КонецПроцедуры

Процедура ОбойтиДеревоДляОтчетаCucumberJson(Дерево, ЗаписьJson, ДопПараметры,ДанныеФичи = Неопределено)
	Для каждого СтрСтроки Из Дерево.Строки Цикл
		Если      СтрСтроки.Тип = "Фича" Тогда

			ЗаписьJson.ЗаписатьНачалоОбъекта(); //начало фичи

			ДопПараметры.Вставить("ТекущаяФичаИмя",СтрСтроки.Имя);

			МассивСценариев = Новый Массив;

			ДанныеФичи = Новый Структура;
			ДанныеФичи.Вставить("МассивСценариев",МассивСценариев);
			ДанныеФичи.Вставить("errors",0);
			ДанныеФичи.Вставить("skipped",0);
			ДанныеФичи.Вставить("tests",0);
			ДанныеФичи.Вставить("failures",0);
			ДанныеФичи.Вставить("time",0);

			ОбойтиДеревоДляОтчетаCucumberJson(СтрСтроки,ЗаписьJson,ДопПараметры,ДанныеФичи);

			ПрефиксИмениСценария = "";
			Если ДобавлятьКИмениСценарияУсловияВыгрузки Тогда
				ПрефиксИмениСценария = ПолучитьПрефиксИмениСценария();
			КонецЕсли;


			ЗаписьJSON.ЗаписатьИмяСвойства("uri");
			ЗаписьJSON.ЗаписатьЗначение(СтрСтроки.Имя);

			ЗаписьJSON.ЗаписатьИмяСвойства("keyword");
			ЗаписьJSON.ЗаписатьЗначение("Feature");

			ЗаписьJSON.ЗаписатьИмяСвойства("id");
			ЗаписьJSON.ЗаписатьЗначение(Транслит(ПрефиксИмениСценария + СтрСтроки.ПолныйПуть));

			ЗаписьJSON.ЗаписатьИмяСвойства("name");
			ЗаписьJSON.ЗаписатьЗначение(ПрефиксИмениСценария + СтрСтроки.Имя);

			//ЗаписьJSON.ЗаписатьИмяСвойства("line");
			//ЗаписьJSON.ЗаписатьЗначение(СтрСтроки.Имя);

			ЗаписьJSON.ЗаписатьИмяСвойства("description");
			ЗаписьJSON.ЗаписатьЗначение("");


			//теги фичи
			ЗаписьJSON.ЗаписатьИмяСвойства("tags");
			ЗаписьJSON.ЗаписатьНачалоМассива();
			Если СтрСтроки.МассивТегов <> Неопределено Тогда
				Для Каждого СвойстваТега Из СтрСтроки.МассивТегов Цикл
					ЗаписьJson.ЗаписатьНачалоОбъекта();

					ЗаписьJSON.ЗаписатьИмяСвойства("name");
					ЗаписьJSON.ЗаписатьЗначение("@" + СвойстваТега.Тег);

					ЗаписьJSON.ЗаписатьИмяСвойства("line");
					ЗаписьJSON.ЗаписатьЗначение(СвойстваТега.НомерСтроки);

					ЗаписьJson.ЗаписатьКонецОбъекта();
				КонецЦикла;
			КонецЕсли;
			ЗаписьJSON.ЗаписатьКонецМассива();


			ЗаписьJSON.ЗаписатьИмяСвойства("elements");
			ЗаписьJSON.ЗаписатьНачалоМассива(); //elements



			НомерСценария = 0;
			Для Каждого Сценарий Из МассивСценариев Цикл
				НомерСценария = НомерСценария + 1;
				ЗаписьJson.ЗаписатьНачалоОбъекта();

				ЗаписьJSON.ЗаписатьИмяСвойства("keyword");
				ЗаписьJSON.ЗаписатьЗначение("Scenario");


				ЗаписьJSON.ЗаписатьИмяСвойства("id");
				ЗаписьJSON.ЗаписатьЗначение(Транслит(ДопПараметры.ТекущаяФичаИмя + "-" +  Сценарий.name + НомерСценария));

				ЗаписьJSON.ЗаписатьИмяСвойства("name");
				ЗаписьJSON.ЗаписатьЗначение(Сценарий.name);

				ЗаписьJSON.ЗаписатьИмяСвойства("line");
				ЗаписьJSON.ЗаписатьЗначение(Сценарий.НомерСтрокиВФиче);

				ЗаписьJSON.ЗаписатьИмяСвойства("description");
				ЗаписьJSON.ЗаписатьЗначение("");

				//теги сценария
				ЗаписьJSON.ЗаписатьИмяСвойства("tags");
				ЗаписьJSON.ЗаписатьНачалоМассива();
				Если Сценарий.МассивТегов <> Неопределено Тогда
					Для Каждого СвойстваТега Из Сценарий.МассивТегов Цикл
						ЗаписьJson.ЗаписатьНачалоОбъекта();

						ЗаписьJSON.ЗаписатьИмяСвойства("name");
						ЗаписьJSON.ЗаписатьЗначение("@" + СвойстваТега.Тег);

						ЗаписьJSON.ЗаписатьИмяСвойства("line");
						ЗаписьJSON.ЗаписатьЗначение(СвойстваТега.НомерСтроки);

						ЗаписьJson.ЗаписатьКонецОбъекта();
					КонецЦикла;
				КонецЕсли;
				ЗаписьJSON.ЗаписатьКонецМассива();


				ЗаписьJSON.ЗаписатьИмяСвойства("type");
				ЗаписьJSON.ЗаписатьЗначение("scenario");

				//шаги сценария
				ЗаписьJSON.ЗаписатьИмяСвойства("steps");
				ЗаписьJSON.ЗаписатьНачалоМассива();
				ЕстьУпавшийШаг        = Ложь;
				ЕстьНеРеализованыйШаг = Ложь;
				Для Каждого Шаг Из Сценарий.МассивШагов Цикл
					ЗаписьJson.ЗаписатьНачалоОбъекта();

					keyword = "";
					name    = "";
					ПолучитьПервоеСлово(Шаг.name,keyword,name);

					ЗаписьJSON.ЗаписатьИмяСвойства("keyword");
					ЗаписьJSON.ЗаписатьЗначение(keyword);

					ЗаписьJSON.ЗаписатьИмяСвойства("name");
					ЗаписьJSON.ЗаписатьЗначение(name);

					ЗаписьJSON.ЗаписатьИмяСвойства("line");
					ЗаписьJSON.ЗаписатьЗначение(Шаг.НомерСтрокиВФиче);

					МассивРисунков = Неопределено;
					Если Шаг.Свойство("embeddings", МассивРисунков) И МассивРисунков.Количество() > 0 Тогда

						ЗаписьJson.ЗаписатьИмяСвойства("embeddings");
						ЗаписьJson.ЗаписатьНачалоМассива();
						Для каждого Элемент из МассивРисунков Цикл

							ЗаписьJson.ЗаписатьНачалоОбъекта();
							ЗаписьJson.ЗаписатьИмяСвойства("mime_type");
							ЗаписьJson.ЗаписатьЗначение(Элемент["mime_type"]);

						    ЗаписьJson.ЗаписатьИмяСвойства("data");
							ЗаписьJson.ЗаписатьЗначение(XMLСтрока(Элемент["data"]));
							ЗаписьJson.ЗаписатьКонецОбъекта();
						КонецЦикла;

						ЗаписьJSON.ЗаписатьКонецМассива();
					КонецЕсли;

					//статус шага
					ЗаписьJSON.ЗаписатьИмяСвойства("result");
					ЗаписьJson.ЗаписатьНачалоОбъекта();

					ЗаписьJSON.ЗаписатьИмяСвойства("status");
					Если Шаг.Статус = "Failed" Тогда
						ЗаписьJSON.ЗаписатьЗначение("failed");

						ЗаписьJSON.ЗаписатьИмяСвойства("error_message");
						Если Шаг.Свойство("message") Тогда
							ЗаписьJSON.ЗаписатьЗначение(Шаг.message);
						Иначе
							//значит ошибка возникла не в шагах, а раньше, например в ПередНачаломСценария()
							ЗаписьJSON.ЗаписатьЗначение(Сценарий.message);
						КонецЕсли;

						ЕстьУпавшийШаг = Истина;
					ИначеЕсли Шаг.Статус = "Pending" Тогда
						Если ЕстьУпавшийШаг Тогда
							ЗаписьJSON.ЗаписатьЗначение("skipped");
						Иначе
							ЗаписьJSON.ЗаписатьЗначение("pending");
							ЕстьНеРеализованыйШаг = Истина;
						КонецЕсли;
					Иначе
						Если ЕстьУпавшийШаг или ЕстьНеРеализованыйШаг Тогда
							ЗаписьJSON.ЗаписатьЗначение("skipped");
						Иначе
							ЗаписьJSON.ЗаписатьЗначение("passed");
						КонецЕсли;
					КонецЕсли;

					ЗаписьJSON.ЗаписатьИмяСвойства("duration");
					ЗаписьJSON.ЗаписатьЗначение((Шаг.stop - Шаг.start)*1000000);

					ЗаписьJson.ЗаписатьКонецОбъекта();


					ЗаписьJson.ЗаписатьКонецОбъекта();
				КонецЦикла;
				ЗаписьJSON.ЗаписатьКонецМассива();

				ЗаписьJson.ЗаписатьКонецОбъекта();
			КонецЦикла;


			ЗаписьJSON.ЗаписатьКонецМассива();//elements
			ЗаписьJson.ЗаписатьКонецОбъекта();//фича
		ИначеЕсли (СтрСтроки.Тип = "Сценарий") или (СтрСтроки.Тип = "Пример") Тогда
			Если (СтрСтроки.ДопТип = "Контекст") Тогда
				//его не надо добавлять в отчет, т.к. этот сценарий включается в каждый сценарий

			ИначеЕсли (СтрСтроки.ДопТип = "СтруктураСценария") или (СтрСтроки.Строки.Количество() = 0) Тогда
				//его не надо добавлять в отчет, т.к. этот сценарий явно не выполняется
				ОбойтиДеревоДляОтчетаCucumberJson(СтрСтроки,ЗаписьJson,ДопПараметры,ДанныеФичи);
			Иначе

				РезультатПрохожденияТестовСценария = ПолучитьРезультатПрохожденияТестовСценария(СтрСтроки);

				Если РезультатПрохожденияТестовСценария = Неопределено Тогда
					Продолжить;
				КонецЕсли;

				Сценарий          = Новый Структура;
				ДанныеФичи.МассивСценариев.Добавить(Сценарий);


				Если СтрСтроки.Тип = "Пример" Тогда
					Сценарий.Вставить("name", СтрСтроки.Родитель.Родитель.Имя + " №" + (СтрСтроки.Родитель.Строки.Индекс(СтрСтроки)));//для структуры сценария надо вести нумерацию
				Иначе
					Сценарий.Вставить("name", СтрСтроки.Имя);
				КонецЕсли;

				classname = Определить_classname(ДопПараметры);
				Сценарий.Вставить("classname",classname);
				Сценарий.Вставить("ПолныйПуть",СтрСтроки.ПолныйПуть);
				Сценарий.Вставить("МассивТегов",СтрСтроки.МассивТегов);

				Если РезультатПрохожденияТестовСценария.Свойство("ВремяОкончания") Тогда
					Сценарий.Вставить("time",РезультатПрохожденияТестовСценария.ВремяОкончания - РезультатПрохожденияТестовСценария.ВремяНачала);
				Иначе
					Сценарий.Вставить("time",0);
				КонецЕсли;
				ДанныеФичи.time = ДанныеФичи.time + Сценарий.time;

				Сценарий.Вставить("МассивШагов",Новый Массив);
				Сценарий.Вставить("id",ПолучитьНомерСтрокиИзПути(СтрСтроки.ПолныйПуть));
				Сценарий.Вставить("НомерСтрокиВФиче",СтрСтроки.НомерСтрокиВФиче);


				ДанныеШага = Неопределено;

				Если СтрСтроки.ДопТип = "СтруктураСценария" Тогда
					ОбойтиДеревоДляОтчетаCucumberJson(СтрСтроки,ЗаписьJson,ДопПараметры,ДанныеФичи);
				Иначе
					Для каждого СтрРезультатПрохожденияТестовШагов Из РезультатПрохожденияТестовСценария.РезультатПрохожденияТестовШагов Цикл

						ДанныеШага = Новый Структура;
						ДанныеШага.Вставить("name",СтрРезультатПрохожденияТестовШагов.Имя);
						ДанныеШага.Вставить("start",0);
						ДанныеШага.Вставить("stop",0);
						ДанныеШага.Вставить("Статус",СтрРезультатПрохожденияТестовШагов.Статус);
						ДанныеШага.Вставить("НомерСтрокиВФиче",РезультатПрохожденияТестовСценария.НомерСтрокиВФиче);
						Если СтрРезультатПрохожденияТестовШагов.ВремяНачала <> Неопределено Тогда
							ДанныеШага.Вставить("start",СтрРезультатПрохожденияТестовШагов.ВремяНачала - РазницаВМилисекундахМеждуЮниксИНачалЭпохи);
							ДанныеШага.Вставить("stop",СтрРезультатПрохожденияТестовШагов.ВремяОкончания - РазницаВМилисекундахМеждуЮниксИНачалЭпохи);
						КонецЕсли;

						Если РезультатПрохожденияТестовСценария.Свойство("МассивСкриншотов") И СтрРезультатПрохожденияТестовШагов.Статус = "Failed" Тогда
							//значит есть скриншоты

							ДанныеШага.Вставить("embeddings", Новый Массив);

							Для каждого СтруктураСкриншот Из РезультатПрохожденияТестовСценария.МассивСкриншотов Цикл
								СтрокаРисунка = Base64Строка(СтруктураСкриншот.ДвоичныеДанные);
								СтрокаРисунка = СтрЗаменить(СтрокаРисунка, Символы.ВК, "");
								СтрокаРисунка = СтрЗаменить(СтрокаРисунка, Символы.ПС, "");
								СтруктураРисунка = Новый Структура("mime_type, data, binarydata", "image/png", СтрокаРисунка, СтруктураСкриншот.ДвоичныеДанные);
								ДанныеШага["embeddings"].Добавить(СтруктураРисунка);
							КонецЦикла;
						КонецЕсли;


						Сценарий.МассивШагов.Добавить(ДанныеШага);

					КонецЦикла;
				КонецЕсли;

				Сценарий.Вставить("Статус",СтрСтроки.Статус);

				ДанныеФичи.tests = ДанныеФичи.tests + 1;

				Если (СтрСтроки.Статус = "Failed")  Тогда
					Сценарий.Вставить("message",РезультатПрохожденияТестовСценария.ОписаниеОшибки);
					Если ДанныеШага <> Неопределено Тогда
						ДанныеШага.Вставить("message",РезультатПрохожденияТестовСценария.ОписаниеОшибки);
					КонецЕсли;
					ДанныеФичи.failures = ДанныеФичи.failures + 1;
				ИначеЕсли (СтрСтроки.Статус = "Pending") Тогда
					Сценарий.Вставить("message",РезультатПрохожденияТестовСценария.ОписаниеОшибки);
					Если ДанныеШага <> Неопределено Тогда
						ДанныеШага.Вставить("message",РезультатПрохожденияТестовСценария.ОписаниеОшибки);
					КонецЕсли;
					ДанныеФичи.skipped = ДанныеФичи.skipped + 1;
				КонецЕсли;
			КонецЕсли;
		ИначеЕсли СтрСтроки.Тип = "Шаг" Тогда
			Если СтрСтроки.Родитель.ДопТип = "СтруктураСценария" Тогда
				//его не надо добавлять в отчет, т.к. этот сценарий явно не выполняется
				ОбойтиДеревоДляОтчетаCucumberJson(СтрСтроки,ЗаписьJson,ДопПараметры,ДанныеФичи);
			КонецЕсли;
		ИначеЕсли СтрСтроки.Тип = "Каталог" Тогда

			ДопПараметры.ТекУровеньКаталога = ДопПараметры.ТекУровеньКаталога + 1;
			//Запоминаем уровни каталогов. Нас интересует только уровень 2 и 3. Т.е. если каталоги лежат как features\Core\FeatureLoad, то мы запомним только Core\FeatureLoad
			Если ДопПараметры.ТекУровеньКаталога = 2 Тогда
				ДопПараметры.УровниКаталогов[0] = СтрСтроки.Имя;
			ИначеЕсли ДопПараметры.ТекУровеньКаталога = 3 Тогда
				ДопПараметры.УровниКаталогов[1] = СтрСтроки.Имя;
			КонецЕсли;


			ОбойтиДеревоДляОтчетаCucumberJson(СтрСтроки,ЗаписьJson,ДопПараметры,ДанныеФичи);


			ДопПараметры.ТекУровеньКаталога = ДопПараметры.ТекУровеньКаталога - 1;
		Иначе
			ОбойтиДеревоДляОтчетаCucumberJson(СтрСтроки,ЗаписьJson,ДопПараметры,ДанныеФичи);
		КонецЕсли;
	КонецЦикла;

КонецПроцедуры

Процедура СформироватьОтчетCucumberJson(СтруктураОФ) Экспорт
	Перем СтарыйКаталог, ПутьКВременномуКаталогуНаСервере, ИмяФайла;
	СтарыйКаталог = КаталогOutputCucumberJson;

	ОтчетВРежимеУФ = Ложь;
	Если СтруктураОФ.ЭтоОФ Тогда
		ОтчетВРежимеУФ = Ложь;
	Иначе
		ОтчетВРежимеУФ = Истина;
		МассивJsonОтчетаCucumberJson = Новый Массив;
		СтруктураОФ.Вставить("МассивJsonОтчетаCucumberJson", МассивJsonОтчетаCucumberJson);


		ПараметрыОтчетаУФ    = СтруктураОФ;
	КонецЕсли;


	ВременныйJson = ПолучитьИмяВременногоФайла("json");

	//делаем запись без BOM
	ЗТ = Новый ЗаписьТекста(ВременныйJson,"Windows-1251",,Ложь);
	ЗТ.Закрыть();

	Попытка
		ЗаписьJson = Вычислить("Новый ЗаписьJson()");
		ТиповойJSON = Истина;
	Исключение
		Если ТекущийРежимЗапуска() = РежимЗапускаКлиентскогоПриложения.ОбычноеПриложение Тогда
			ЗаписьJson = ПолучитьФорму("ЗаписьJSON");
		Иначе
			Возврат;
		КонецЕсли;
		ТиповойJSON = Ложь;
	КонецПопытки;
	Если ТиповойJSON Тогда
		ЗаписьJson.ОткрытьФайл(ВременныйJson,,Ложь,Вычислить("Новый ПараметрыЗаписиJSON(,Символы.Таб)"));
	Иначе
		ЗаписьJson.ОткрытьФайл(ВременныйJson, Символы.Таб);
	КонецЕсли;

	ЗаписьJson.ЗаписатьНачалоМассива();

	ДопПараметры = Новый Структура;
	ДопПараметры.Вставить("УровниКаталогов",Новый Массив);
	ДопПараметры.УровниКаталогов.Добавить("");
	ДопПараметры.УровниКаталогов.Добавить("");

	ДопПараметры.Вставить("ТекУровеньКаталога",0);
	ОбойтиДеревоДляОтчетаCucumberJson(ДеревоТестов, ЗаписьJson,ДопПараметры);

	ЗаписьJson.ЗаписатьКонецМассива();
	Если ТиповойJSON Тогда
		ЗаписьJson.Закрыть();
	Иначе
		ЗаписьJson.ЗакрытьФайл();
	КонецЕсли;

	ДД = Новый ДвоичныеДанные(ВременныйJson);
	СтруктураОФ.Вставить("Json",ДД);
	УдалитьФайлы(ВременныйJson);

КонецПроцедуры

//}

Функция ПолучитьРезультатПрохожденияТестовСценария(СтрСтроки)

	РезультатПрохожденияТестовСценария = Неопределено;

	Если ОтчетВРежимеУФ Тогда
		ИДВМассиве                         = ПараметрыОтчетаУФ.МассивИДСтрокиДерева.Найти(СтрСтроки.ИДСтроки);
		Если ИДВМассиве <> Неопределено Тогда
			РезультатПрохожденияТестовСценария = ПараметрыОтчетаУФ.МассивРезультатПрохожденияТестовСценария[ИДВМассиве];
		КонецЕсли;
	Иначе
		РезультатПрохожденияТестовСценария = СтрСтроки.РезультатПрохожденияТестовСценария;
	КонецЕсли;

	Возврат РезультатПрохожденияТестовСценария;

КонецФункции
//портирован блок ассертов из проекта xUnitFor1C (https://github.com/xDrivenDevelopment/xUnitFor1C)
//был взят релиз 3.0.0.3
//{ МЕТОДЫ ДЛЯ ПРОВЕРКИ ЗНАЧЕНИЙ (assertions).
Функция ФорматДСО(ДопСообщениеОшибки)
	Если ДопСообщениеОшибки = "" Тогда
		Возврат "";
	КонецЕсли;

	Возврат Символы.ПС + ДопСообщениеОшибки;
КонецФункции

Процедура Проверить(_Истина, ДопСообщениеОшибки = "") Экспорт
	Если Не _Истина Тогда
		СообщениеОшибки = "Переданный параметр ("+Формат(_Истина, "БЛ=ложь; БИ=истина")+") не является Истиной, а хотели, чтобы являлся." + ФорматДСО(ДопСообщениеОшибки);
		ВызватьОшибкуПроверки(СообщениеОшибки);
	КонецЕсли;
КонецПроцедуры

Процедура ПроверитьИстину(_Истина, ДопСообщениеОшибки = "") Экспорт
	Проверить(_Истина, ДопСообщениеОшибки);
КонецПроцедуры

Процедура ПроверитьЛожь(_Ложь, ДопСообщениеОшибки = "") Экспорт
	Если _Ложь Тогда
		СообщениеОшибки = "Переданный параметр ("+Формат(_Ложь, "БЛ=ложь; БИ=истина")+") не является Ложью, а хотели, чтобы являлся." + ФорматДСО(ДопСообщениеОшибки);
		ВызватьОшибкуПроверки(СообщениеОшибки);
	КонецЕсли;
КонецПроцедуры

Процедура ПроверитьДату(_Дата, _Период, ДопСообщениеОшибки = "") Экспорт
	Если _Дата < _Период.ДатаНачала или _Дата > _Период.ДатаОкончания Тогда
		представление = ПредставлениеПериода(_Период.ДатаНачала, _Период.ДатаОкончания, "ФП = Истина");
		СообщениеОшибки = "Переданный параметр ("+Формат(_Дата, "ДФ='dd.MM.yyyy HH:mm:ss'")+") не входит в период "+представление+", а хотели, чтобы являлся." + ФорматДСО(ДопСообщениеОшибки);
		ВызватьОшибкуПроверки(СообщениеОшибки);
	КонецЕсли;
КонецПроцедуры

Процедура ПроверитьРавенствоДатСТочностью2Секунды(_Дата, _Дата2, ДопСообщениеОшибки = "") Экспорт
	Если _Дата < _Дата2-2 или _Дата > _Дата2+2 Тогда
		СообщениеОшибки = "Переданная дата ("+Формат(_Дата, "ДФ='dd.MM.yyyy HH:mm:ss'")+") не равна дате ("+Формат(_Дата2, "ДФ='dd.MM.yyyy HH:mm:ss'")+") с точностью до 2-х секунд, а хотели, чтобы они равнялись." + ФорматДСО(ДопСообщениеОшибки);
		ВызватьОшибкуПроверки(СообщениеОшибки);
	КонецЕсли;
КонецПроцедуры

Процедура ПроверитьРавенство(_1, _2, ДопСообщениеОшибки = "") Экспорт
	Если _1 <> _2 Тогда
		СообщениеОшибки = "Сравниваемые значения ("+_1+"; "+_2+") не равны, а хотели, чтобы были равны." + ФорматДСО(ДопСообщениеОшибки);
		ВызватьОшибкуПроверки(СообщениеОшибки);
	КонецЕсли;
КонецПроцедуры

Процедура ПроверитьНеРавенство(_1, _2, ДопСообщениеОшибки = "") Экспорт
	Если _1 = _2 Тогда
		СообщениеОшибки = "Сравниваемые значения ("+_1+"; "+_2+") равны, а хотели, чтобы были не равны." + ФорматДСО(ДопСообщениеОшибки);
		ВызватьОшибкуПроверки(СообщениеОшибки);
	КонецЕсли;
КонецПроцедуры

Процедура ПроверитьБольше(_Больше, _Меньше, ДопСообщениеОшибки = "") Экспорт
	Если _Больше <= _Меньше Тогда
		СообщениеОшибки = "Первый параметр ("+_Больше+") меньше или равен второму ("+_Меньше+") а хотели, чтобы был больше." + ФорматДСО(ДопСообщениеОшибки);
		ВызватьОшибкуПроверки(СообщениеОшибки);
	КонецЕсли;
КонецПроцедуры

Процедура ПроверитьБольшеИлиРавно(_Больше, _Меньше, ДопСообщениеОшибки = "") Экспорт
	Если _Больше < _Меньше Тогда
		СообщениеОшибки = "Первый параметр ("+_Больше+") меньше второго ("+_Меньше+") а хотели, чтобы был больше или равен." + ФорматДСО(ДопСообщениеОшибки);
		ВызватьОшибкуПроверки(СообщениеОшибки);
	КонецЕсли;
КонецПроцедуры

Процедура ПроверитьМеньше(проверяемоеЗначение1, проверяемоеЗначение2, СообщениеОбОшибке = "") Экспорт
	Если проверяемоеЗначение1 >= проверяемоеЗначение2 Тогда
		СообщениеОшибки = "Значение <"+проверяемоеЗначение1+"> больше или равно, чем <"+проверяемоеЗначение2+">, а ожидалось меньше"+
				ФорматДСО(СообщениеОбОшибке);
		ВызватьОшибкуПроверки(СообщениеОшибки)
	КонецЕсли;
КонецПроцедуры

Процедура ПроверитьМеньшеИлиРавно(проверяемоеЗначение1, проверяемоеЗначение2, СообщениеОбОшибке = "") Экспорт
	Если проверяемоеЗначение1 > проверяемоеЗначение2 Тогда
		СообщениеОшибки = "Значение <"+проверяемоеЗначение1+"> больше, чем <"+проверяемоеЗначение2+">, а ожидалось меньше или равно"+
				ФорматДСО(СообщениеОбОшибке);
		ВызватьОшибкуПроверки(СообщениеОшибки)
	КонецЕсли;
КонецПроцедуры

Процедура ПроверитьВыполнилось(Знач СтрокаАлгоритм, ПараметрыИлиДопСообщениеОшибки = Неопределено, Знач ДопСообщениеОшибки = "") Экспорт
	Перем Параметры;

	Если ТипЗнч(ПараметрыИлиДопСообщениеОшибки) = Тип("Строка") Тогда
		ДопСообщениеОшибки = ПараметрыИлиДопСообщениеОшибки;
	Иначе
		Параметры = ПараметрыИлиДопСообщениеОшибки;
	КонецЕсли;
	Попытка
		Выполнить(СтрокаАлгоритм);
	Исключение
		ПолученноеОписаниеОшибки = ПодробноеПредставлениеОшибки(ИнформацияОбОшибке());
		СообщениеОшибки = "Хотели, чтобы алгоритм """+СтрокаАлгоритм+""" выполнился, а он упал с ошибкой """+ПолученноеОписаниеОшибки+"""." + ФорматДСО(ДопСообщениеОшибки);
		ВызватьОшибкуПроверки(СообщениеОшибки);
	КонецПопытки;

КонецПроцедуры

Процедура ПроверитьМетодВыполнился(Объект, Знач ИмяМетода, ПараметрыИлиДопСообщениеОшибки = Неопределено, Знач ДопСообщениеОшибки = "") Экспорт
	Перем Параметры;

	Если ТипЗнч(ПараметрыИлиДопСообщениеОшибки) = Тип("Строка") Тогда
		ДопСообщениеОшибки = ПараметрыИлиДопСообщениеОшибки;
	Иначе
		Параметры = ПараметрыИлиДопСообщениеОшибки;
		Если Параметры <> Неопределено Тогда
			ТипПараметра = ТипЗнч(Параметры);
			Если ТипПараметра <> Тип("Массив") Тогда
				ВызватьИсключение ("Ожидали, что вторым параметром будет передан массив параметров для метода <"+ИмяМетода+">, а получили другой объект с типом <"+ТипПараметра+">");
			КонецЕсли;
		КонецЕсли;
	КонецЕсли;

	ПараметрыСтрока = ПараметрыСтрокой(Параметры);

	СтрокаВыполнения = "Объект." + ИмяМетода + "(" + ПараметрыСтрока + ")";

	Попытка
		Выполнить(СтрокаВыполнения);
	Исключение
		ПолученноеОписаниеОшибки = ПодробноеПредставлениеОшибки(ИнформацияОбОшибке());
		СообщениеОшибки = "Хотели, чтобы код """+СтрокаВыполнения+""" выполнился, а он упал с ошибкой """+ПолученноеОписаниеОшибки+"""." + ФорматДСО(ДопСообщениеОшибки);
		ВызватьОшибкуПроверки(СообщениеОшибки);
	КонецПопытки;

КонецПроцедуры

Функция ПараметрыСтрокой(Параметры, ИмяПеременной = "Параметры")

	ПараметрыСтрока = "";
	Если Параметры <> Неопределено Тогда
		Если ТипЗнч(Параметры) = Тип("Массив") Тогда
			Для Индекс = 0 По Параметры.ВГраница() Цикл
				ПараметрыСтрока = ПараметрыСтрока + ", " + ИмяПеременной + "[" + Формат(Индекс, "ЧН=0; ЧГ=0") + "]";
			КонецЦикла;
			ПараметрыСтрока = Сред(ПараметрыСтрока, 3);
		Иначе
			ПараметрыСтрока = ИмяПеременной;
		КонецЕсли;
	КонецЕсли;

	Возврат ПараметрыСтрока;

КонецФункции

Процедура ПроверитьНеВыполнилось(Знач СтрокаАлгоритм, ПараметрыИлиОжидаемоеОписаниеОшибки, Знач ОжидаемоеОписаниеОшибкиИлиДопСообщениеОшибки = "", Знач ДопСообщениеОшибки = "") Экспорт
	Перем Параметры, ОжидаемоеОписаниеОшибки;
	Если ТипЗнч(ПараметрыИлиОжидаемоеОписаниеОшибки) = Тип("Строка") Тогда
		ОжидаемоеОписаниеОшибки = ПараметрыИлиОжидаемоеОписаниеОшибки;
		ДопСообщениеОшибки = ОжидаемоеОписаниеОшибкиИлиДопСообщениеОшибки;
	Иначе
		Параметры = ПараметрыИлиОжидаемоеОписаниеОшибки;
		ОжидаемоеОписаниеОшибки = ОжидаемоеОписаниеОшибкиИлиДопСообщениеОшибки;
	КонецЕсли;
	Попытка
		Выполнить(СтрокаАлгоритм);
	Исключение
		ПолученноеОписаниеОшибки = ПодробноеПредставлениеОшибки(ИнформацияОбОшибке());
		Если Найти(ПолученноеОписаниеОшибки, ОжидаемоеОписаниеОшибки) = 0 Тогда
			ВызватьОшибкуПроверки("Хотели, чтобы алгоритм """+СтрокаАлгоритм+""" упал с сообщением об ошибке """+ОжидаемоеОписаниеОшибки+""", а он упал с сообщением """+ПолученноеОписаниеОшибки+"""." + ФорматДСО(ДопСообщениеОшибки));
		КонецЕсли;
		Возврат;
	КонецПопытки;

	ВызватьОшибкуПроверки("Хотели, чтобы алгоритм """+СтрокаАлгоритм+""" упал, а он выполнился" + ФорматДСО(ДопСообщениеОшибки));

КонецПроцедуры

Процедура ПроверитьМетодНеВыполнился(Объект, ИмяМетода, ПараметрыИлиОжидаемоеОписаниеОшибки, Знач ОжидаемоеОписаниеОшибкиИлиДопСообщениеОшибки = "", Знач ДопСообщениеОшибки = "") Экспорт
	Перем Параметры, ОжидаемоеОписаниеОшибки;

	Если ТипЗнч(ПараметрыИлиОжидаемоеОписаниеОшибки) = Тип("Строка") Тогда
		ОжидаемоеОписаниеОшибки = ПараметрыИлиОжидаемоеОписаниеОшибки;
		ДопСообщениеОшибки = ОжидаемоеОписаниеОшибкиИлиДопСообщениеОшибки;
	Иначе
		Параметры = ПараметрыИлиОжидаемоеОписаниеОшибки;
		Если Параметры <> Неопределено Тогда
			ТипПараметра = ТипЗнч(Параметры);
			Если ТипПараметра <> Тип("Массив") Тогда
				ВызватьИсключение ("Ожидали, что третьим параметром будет передан массив параметров для метода <"+ИмяМетода+">, а получили другой объект с типом <"+ТипПараметра+">");
			КонецЕсли;
		КонецЕсли;
		ОжидаемоеОписаниеОшибки = ОжидаемоеОписаниеОшибкиИлиДопСообщениеОшибки;
	КонецЕсли;

	ПараметрыСтрока = ПараметрыСтрокой(Параметры);

	СтрокаВыполнения = "Объект." + ИмяМетода + "(" + ПараметрыСтрока + ")";

	Попытка
		Выполнить(СтрокаВыполнения);
	Исключение
		ПолученноеОписаниеОшибки = ПодробноеПредставлениеОшибки(ИнформацияОбОшибке());
		Если Найти(ПолученноеОписаниеОшибки, ОжидаемоеОписаниеОшибки) = 0 Тогда
			ВызватьОшибкуПроверки("Хотели, чтобы код """+СтрокаВыполнения+""" упал с сообщением об ошибке """+ОжидаемоеОписаниеОшибки+""", а он упал с сообщением """+ПолученноеОписаниеОшибки+"""." + ФорматДСО(ДопСообщениеОшибки));
		КонецЕсли;
		Возврат;
	КонецПопытки;

	ВызватьОшибкуПроверки("Хотели, чтобы код """+СтрокаВыполнения+""" упал, а он выполнился" + ФорматДСО(ДопСообщениеОшибки));

КонецПроцедуры

// проверка идет через ЗначениеЗаполнено, но мутабельные значение всегда считаем заполненными
Процедура ПроверитьЗаполненность(ПроверяемоеЗначение, ДопСообщениеОшибки = "") Экспорт
	Попытка
		фЗаполнено = ЗначениеЗаполнено(ПроверяемоеЗначение);
	Исключение
		Возврат;
	КонецПопытки;
	Если НЕ фЗаполнено Тогда
		ВызватьОшибкуПроверки("Значение ("+ПроверяемоеЗначение+") не заполнено, а ожидалась заполненность" + ФорматДСО(ДопСообщениеОшибки));
	КонецЕсли;
КонецПроцедуры

Процедура ПроверитьНеЗаполненность(ПроверяемоеЗначение, ДопСообщениеОшибки = "") Экспорт
	СообщениеОшибки = "Значение ("+ПроверяемоеЗначение+") заполнено, а ожидалась незаполненность" + ФорматДСО(ДопСообщениеОшибки);
	Попытка
		фЗаполнено = ЗначениеЗаполнено(ПроверяемоеЗначение);
	Исключение
		ВызватьОшибкуПроверки(СообщениеОшибки);
	КонецПопытки;
	Если фЗаполнено Тогда
		ВызватьОшибкуПроверки(СообщениеОшибки);
	КонецЕсли;
КонецПроцедуры

Процедура ПроверитьТип(значение, ТипИлиИмяТипа, ДопСообщениеОшибки = "") Экспорт
	Если ТипЗнч(ТипИлиИмяТипа) = Тип("Строка") Тогда
		искомыйТип = Тип(ТипИлиИмяТипа);
	ИначеЕсли ТипЗнч(ТипИлиИмяТипа) = Тип("Тип") Тогда
		искомыйТип = ТипИлиИмяТипа;
	Иначе
		ВызватьИсключение ("ПроверитьТип: Тип значения параметра ТипИлиИмяТипа должен быть <Тип> или <Строка>, а получили <"+ ТипЗнч(ТипИлиИмяТипа) + ">" + ФорматДСО(ДопСообщениеОшибки));
	КонецЕсли;
	Если ТипЗнч(значение) <> искомыйТип Тогда
		ВызватьОшибкуПроверки("Типом значения <"+значение+"> является <"+ТипЗнч(значение)+">, а ожидался тип <"+ТипИлиИмяТипа+">."+ФорматДСО(ДопСообщениеОшибки));
	КонецЕсли;
КонецПроцедуры

Процедура ПроверитьВхождение(строка, подстрокаПоиска, ДопСообщениеОшибки = "") Экспорт
	Если Найти(строка, подстрокаПоиска) = 0 Тогда
		ПредставлениеСтроки = "<"+строка+">";
		Если СтрДлина(строка) > 20 Тогда
			ПредставлениеСтроки = ПредставлениеСтроки + Символы.ПС;
		КонецЕсли;
		ПредставлениеПодСтроки = "<"+подстрокаПоиска+">";
		Если СтрДлина(подстрокаПоиска) > 20 Тогда
			ПредставлениеПодСтроки = ПредставлениеПодСтроки + Символы.ПС;
		КонецЕсли;
		СообщениеОшибки = "Искали в "+ПредставлениеСтроки+" подстроку "+ПредставлениеПодСтроки+", но не нашли." + ФорматДСО(ДопСообщениеОшибки);
		ВызватьОшибкуПроверки(СообщениеОшибки);
	КонецЕсли;
КонецПроцедуры

//Коллекция - Массив, Структура, Соответствие, ФиксированныйМассив, ФиксированнаяСтруктура, ФиксированноеСоответствие, СписокЗначений
Процедура ПроверитьВхождениеВКоллекцию(Элемент, Коллекция, ДопСообщениеОшибки = "") Экспорт
	Нашли = Неопределено;
	ТипКоллекции = ТипЗнч(Коллекция);
	Если ТипКоллекции = Тип("Массив") или ТипКоллекции = Тип("ФиксированныйМассив") Тогда
		Нашли = Коллекция.Найти(Элемент) <> Неопределено;
	ИначеЕсли ТипКоллекции = Тип("Структура") или ТипКоллекции = Тип("Соответствие")
			или ТипКоллекции = Тип("ФиксированнаяСтруктура") или ТипКоллекции = Тип("ФиксированноеСоответствие") Тогда
		Для каждого КлючЗначение Из Коллекция Цикл
			Нашли = КлючЗначение.Значение = Элемент;
			Если Нашли Тогда
				Прервать;
			КонецЕсли;
		КонецЦикла;
	ИначеЕсли ТипКоллекции = Тип("СписокЗначений") Тогда
		Нашли = Коллекция.НайтиПоЗначению(Элемент) <> Неопределено;
	КонецЕсли;
	Если Нашли = Неопределено Тогда
		СообщениеОшибки = "Утверждение ""ПроверитьВхождениеВКоллекцию"" не умеет работать с типом коллекции <"+ТипКоллекции+">." + ФорматДСО(ДопСообщениеОшибки);
		ВызватьИсключение СообщениеОшибки;
	КонецЕсли;
	Если Не Нашли Тогда
		СообщениеОшибки = "Не нашли элемент <"+Элемент+"> в коллекции, а хотели, чтобы он был в коллекции." + ФорматДСО(ДопСообщениеОшибки);
		ВызватьОшибкуПроверки(СообщениеОшибки);
	КонецЕсли;
КонецПроцедуры

Процедура ПроверитьВалидностьЗапросаСКД(ТекстЗапроса, ДопСообщениеОшибки = "") Экспорт

	СхемаКомпоновкиДанных = Новый СхемаКомпоновкиДанных;

	ИсточникДанных 					  = СхемаКомпоновкиДанных.ИсточникиДанных.Добавить();
	ИсточникДанных.Имя                = "ИсточникДанных";
	ИсточникДанных.СтрокаСоединения   = "";
	ИсточникДанных.ТипИсточникаДанных = "Local";

	НаборДанных 							 = СхемаКомпоновкиДанных.НаборыДанных.Добавить(Тип("НаборДанныхЗапросСхемыКомпоновкиДанных"));
	НаборДанных.Имя            				 = "НаборДанных";
	НаборДанных.ИсточникДанных 				 = "ИсточникДанных";
	НаборДанных.АвтоЗаполнениеДоступныхПолей = Истина;
	НаборДанных.Запрос 						 = ТекстЗапроса;

	КомпоновщикНастроек = Новый КомпоновщикНастроекКомпоновкиДанных;
	Попытка
		КомпоновщикНастроек.Инициализировать(Новый ИсточникДоступныхНастроекКомпоновкиДанных(СхемаКомпоновкиДанных));
	Исключение
		СообщениеОшибки = ОписаниеОшибки() + "." + ФорматДСО(ДопСообщениеОшибки);
		ВызватьОшибкуПроверки(СообщениеОшибки);
	КонецПопытки;

КонецПроцедуры // ПроверитьВалидностьЗапросаСКД()

Процедура ПроверитьНаличиеОбъектаИБ(ссылка, ДопСообщениеОшибки = "") Экспорт
	Если Не ЗначениеЗаполнено(ссылка) Тогда
		СообщениеОшибки = "Ожидали заполненность ссылки, а получили пустую ссылку." + ФорматДСО(ДопСообщениеОшибки);
		ВызватьОшибкуПроверки(СообщениеОшибки);
	КонецЕсли;
	лОбъект = ссылка.ПолучитьОбъект();
	Если лОбъект = Неопределено Тогда
		СообщениеОшибки = "Ожидали существование объекта в ИБ, а получили объект не найден <" + ссылка + "> ." + ФорматДСО(ДопСообщениеОшибки);
		ВызватьОшибкуПроверки(СообщениеОшибки);
	КонецЕсли;
КонецПроцедуры

// Проеряет равенство файлов
// Параметры:
//  ПутьФайла1, ПутьФайла2 - полные пути к фалйам
//  ПарамСравнениеФайлов - структура с ключами:
//                ИгнорироватьПустоеПространство
//                СпособСравнения
//                УчитыватьРазделителиСтрок
//                УчитыватьРегистр
//  ПоказатьРазличия - в случае ошибки появляется окно сравнеия (для отладки)
Процедура ПроверитьРавенствоФайлов(ПутьФайла1, ПутьФайла2, ДопСообщениеОшибки = "", ПарамСравнениеФайлов = Неопределено, ПоказатьРазличия = Ложь) Экспорт
#Если ТолстыйКлиентОбычноеПриложение или ТолстыйКлиентУправляемоеПриложение Тогда
	Если ПарамСравнениеФайлов = Неопределено Тогда
		ПарамСравнениеФайлов = Новый Структура;
	КонецЕсли;
	СравнениеФайлов = Новый СравнениеФайлов;
	СравнениеФайлов.ПервыйФайл = ПутьФайла1;
	СравнениеФайлов.ВторойФайл = ПутьФайла2;
	Если Не ПарамСравнениеФайлов.Свойство("СпособСравнения") Тогда
		Файл = Новый Файл(ПутьФайла1);
		ТипФайла = НРег(Файл.Расширение);
		ТекстовыеТипы = ".txt,.xml";
		Если ТипФайла = ".mxl" Тогда
			ПарамСравнениеФайлов.Вставить("СпособСравнения", СпособСравненияФайлов.ТабличныйДокумент);
		ИначеЕсли Найти(ТекстовыеТипы, ТипФайла) > 0 Тогда
			ПарамСравнениеФайлов.Вставить("СпособСравнения", СпособСравненияФайлов.ТекстовыйДокумент);
		КонецЕсли;
	КонецЕсли;
	ЗаполнитьЗначенияСвойств(СравнениеФайлов, ПарамСравнениеФайлов);
	ФайлыИдентичны = СравнениеФайлов.Сравнить();
	Если Не ФайлыИдентичны Тогда
		Если ПоказатьРазличия Тогда // для удобства отладки и расследования ошибок
			СравнениеФайлов.ПоказатьРазличия();
		КонецЕсли;
		СообщениеОшибки = "Ожидали идентичность файлов, а получили, что они различны." + ФорматДСО(ДопСообщениеОшибки);
		ВызватьОшибкуПроверки(СообщениеОшибки);
	КонецЕсли;
#Иначе
	ВызватьИсключение "Утверждение ПроверитьРавенствоФайлов можно использовать только в толстом клиенте!";
#КонецЕсли
КонецПроцедуры

//TODO исправить дублирование метода СравнитьТаблицы в плагине УтвержденияПроверкаТаблиц
Функция СравнитьТаблицы(ТаблицаОжиданий, ТаблицаРезультатов, ТаблицаРазличий,
		ДопСообщениеОшибки = "", ДопПараметры = Неопределено)

	Если ДопПараметры = Неопределено ИЛИ ТипЗнч(ДопПараметры) <> Тип("Структура") Тогда
		ДопПараметры = Новый Структура;
	КонецЕсли;

	Если ТаблицаОжиданий.Количество() <> ТаблицаРезультатов.Количество() Тогда
		ДопСообщениеОшибки = "ТаблицаОжиданий.КоличествоСтрок()="+ТаблицаОжиданий.Количество() + ", ТаблицаРезультатов.Количество()="+ТаблицаРезультатов.Количество();
		Возврат РезультатыСравненияТаблиц.РазноеКоличествоСтрок;
	КонецЕсли;

	Если ТаблицаОжиданий.Количество() = 0 Тогда
		Возврат РезультатыСравненияТаблиц.ТаблицыСовпадают; //Пустые таблицы всегда одинаковы
	КонецЕсли;

	//Проверим структуру колонок

	//TODO При этом сравнении в структуре ТаблицаРезультатов может оказаться больше колонок, чем в ТаблицаОжиданий,
	// так что для абсолютного точного сравнения нужно добавить проверку совпадения количества колонок.
	ОжидаемыеКолонки = ТаблицаОжиданий.Колонки;
	КолонкиРезультата = ТаблицаРезультатов.Колонки;
	Для Каждого Колонка Из ОжидаемыеКолонки Цикл
		Если КолонкиРезультата.Найти(Колонка.Имя) = Неопределено Тогда
			ДопСообщениеОшибки = "КолонкиЭталона.Количество()=" + ОжидаемыеКолонки.Количество() + ", КолонкиРезультата.Количество()=" + КолонкиРезультата.Количество();
			Возврат РезультатыСравненияТаблиц.РазличаютсяКолонки;
		КонецЕсли;
	КонецЦикла;

	Возврат СравнитьЗначенияТаблиц(ТаблицаОжиданий, ТаблицаРезультатов, ТаблицаРазличий, ДопПараметры);

КонецФункции

//позволяет сделать поиск в строке "ПроверяемаяСтрока" подстроки "Шаблон"
//при этом подстрока "Шаблон" может содержать символы *
//например СтрокаСоответствуетШаблону("Привет","*вет")
Функция СтрокаСоответствуетШаблону(ПроверяемаяСтрока, Знач Шаблон) Экспорт

	РегулярныеВыражения = Плагин("РегулярныеВыражения");
	Нашли = РегулярныеВыражения.СтрокаСоответствуетШаблону(ПроверяемаяСтрока, Шаблон);
	Возврат Нашли;

КонецФункции

// портирован из Functest
Функция СравнитьЗначенияТаблиц(ТаблицаОжиданий, ТаблицаРезультатов, Различия,ДопПараметры)
	СравнениеПоШаблону = Ложь;
	Если ДопПараметры <> Неопределено Тогда
		Если ДопПараметры.Свойство("СравнениеПоШаблону") Тогда
			СравнениеПоШаблону = ДопПараметры.СравнениеПоШаблону;
		КонецЕсли;
	КонецЕсли;


	Различия = Новый ТаблицаЗначений;
	Различия.Колонки.Очистить();
	Различия.Колонки.Добавить("Строка",Новый ОписаниеТипов("Число"));
	Различия.Колонки.Добавить("Колонка",Новый ОписаниеТипов("Строка"));
	Различия.Колонки.Добавить("Ожидание");
	Различия.Колонки.Добавить("Результат");

	РезультатСравнения = РезультатыСравненияТаблиц.ТаблицыСовпадают;

	Колонки = ТаблицаОжиданий.Колонки;
	ГраницаСтрок = ТаблицаОжиданий.Количество() - 1;
	Для Индекс = 0 По ГраницаСтрок Цикл

		ОжидаемаяСтрока = ТаблицаОжиданий[Индекс];
		СтрокаРезультата = ТаблицаРезультатов[Индекс];

		Для Каждого Колонка Из Колонки Цикл
			ИмяКолонки = Колонка.Имя;

			ОжидаемоеЗначение = ОжидаемаяСтрока[ИмяКолонки];
			ЗначениеРезультата = СтрокаРезультата[ИмяКолонки];

			Если ОжидаемоеЗначение = "*" Тогда
				Продолжить;
			КонецЕсли;

			ОжидаемоеЗначение  = СтрЗаменить(ОжидаемоеЗначение,Символы.НПП," ");
			ЗначениеРезультата = СтрЗаменить(ЗначениеРезультата,Символы.НПП," ");

			ОжидаемоеЗначение  = СтрЗаменить(ОжидаемоеЗначение,Символы.ПС,"\n");
			ЗначениеРезультата = СтрЗаменить(ЗначениеРезультата,Символы.ПС,"\n");

			Если НЕ СравнениеПоШаблону Тогда
				Если ОжидаемоеЗначение = ЗначениеРезультата
					Или (Не ЗначениеЗаполнено(ОжидаемоеЗначение) И Не ЗначениеЗаполнено(ЗначениеРезультата)) Тогда //Пустые значения разных типов 1С-м не считаются равными :(
					Продолжить;
				КонецЕсли;
			Иначе
				Если СтрокаСоответствуетШаблону(ЗначениеРезультата,ОжидаемоеЗначение) Тогда
					Продолжить;
				КонецЕсли;
			КонецЕсли;




			Различие = Различия.Добавить();
			Различие.Строка = Индекс + 1;
			Различие.Колонка = ИмяКолонки;
			Различие.Ожидание = ОжидаемоеЗначение;
			Различие.Результат = ЗначениеРезультата;
			РезультатСравнения = РезультатыСравненияТаблиц.НеСовпадаютЗначенияВЯчейкеТаблицы;

		КонецЦикла;

	КонецЦикла;

	Возврат РезультатСравнения;

КонецФункции

Процедура ПроверитьРавенствоТаблиц(Таб1, Таб2, ДопСообщениеОшибки = "", ДопПараметры = Неопределено) Экспорт

	Если ТипЗнч(Таб1) <> Тип("ТаблицаЗначений") Тогда
		ВызватьИсключение "ПроверитьРавенствоТаблиц: Первый параметр-таблица таблицей не является";
	КонецЕсли;
	Если ТипЗнч(Таб2) <> Тип("ТаблицаЗначений") Тогда
		ВызватьИсключение "ПроверитьРавенствоТаблиц: Второй параметр-таблица таблицей не является";
	КонецЕсли;

	Различия = Новый ТаблицаЗначений;
	РезультатСравнения = СравнитьТаблицы(Таб1, Таб2, Различия, ДопСообщениеОшибки, ДопПараметры);

	Если РезультатыСравненияТаблиц.ТаблицыСовпадают <> РезультатСравнения Тогда

		ИменаРезультатов = Новый Соответствие;
		Для Каждого КлючЗначение Из РезультатыСравненияТаблиц Цикл
			ИменаРезультатов.Вставить(КлючЗначение.Значение, КлючЗначение.Ключ);
		КонецЦикла;
		СтрокаОшибок = "Различия в таблицах:" + Символы.ПС;
		СтрокаОшибок = СтрокаОшибок + "Ожидали статус <" + ИменаРезультатов[РезультатыСравненияТаблиц.ТаблицыСовпадают] + ">, а получили <" + ИменаРезультатов[РезультатСравнения] + ">" + Символы.ПС;
		Для Каждого Строка Из Различия Цикл
			СтрокаОшибок = СтрокаОшибок + "Значение [" + Строка.Колонка + ":" + Строка.Строка + "]. Ожидали <" + Строка.Ожидание + ">, а получили <" + Строка.Результат + ">" + Символы.ПС;
		КонецЦикла;

		ВызватьОшибкуПроверки("Таблицы должны совпадать, а они различны" + Символы.ПС + СтрокаОшибок + Символы.ПС + ДопСообщениеОшибки);

	КонецЕсли;

КонецПроцедуры

Процедура ПроверитьРавенствоТабличныхДокументовТолькоПоЗначениям(ТабДок1, ТабДок2, УчитыватьТолькоВидимыеКолонкиИлиДопСообщениеОшибки = Ложь, УчитыватьТолькоВидимыеСтрокиИлиДопСообщениеОшибки = Ложь, Знач ДопСообщениеОшибки = "",ДопПараметры = Неопределено) Экспорт

	УтвержденияПроверкаТаблиц = Плагин("УтвержденияПроверкаТаблиц");
	УтвержденияПроверкаТаблиц.ПроверитьРавенствоТабличныхДокументовТолькоПоЗначениям(ТабДок1, ТабДок2, УчитыватьТолькоВидимыеКолонкиИлиДопСообщениеОшибки, УчитыватьТолькоВидимыеСтрокиИлиДопСообщениеОшибки, ДопСообщениеОшибки, ДопПараметры);

КонецПроцедуры

Процедура ВызватьОшибкуПроверки(СообщениеОшибки)

	Префикс = "["+ СтатусыРезультатаТестирования.ОшибкаПроверки + "]";
	ВызватьИсключение Префикс + " " + СообщениеОшибки;

КонецПроцедуры

Процедура ПропуститьТест(Знач Сообщение = "") Экспорт

	Префикс = "[" + СтатусыРезультатаТестирования.ТестПропущен + "]";
	Если ПустаяСтрока(Сообщение) Тогда
		Сообщение = НСтр("ru = 'Тест пропущен'");
	КонецЕсли;
	ВызватьИсключение Префикс + " " + Сообщение;

КонецПроцедуры

//} МЕТОДЫ ДЛЯ ПРОВЕРКИ ЗНАЧЕНИЙ (assertions).

//портирован блок генерации данных из проекта xUnitFor1C (https://github.com/xDrivenDevelopment/xUnitFor1C)
//был взят релиз 3.0.0.3
// { Методы генерации тестовых данных

Функция СоздатьДанныеПоМакетам(ТестОбъект, ИменаМакетов) Экспорт
	Сериализатор = Плагин("СериализаторMXL");
	Возврат Сериализатор.СоздатьДанныеПоМакетам(ТестОбъект, ИменаМакетов);
КонецФункции

Функция СоздатьДанныеПоТабличномуДокументу(ТабличныйДокументИлиМассивТабличныхДокументов, РежимыЗагрузкиИлиИмяКолонкиЗамещения = Неопределено, ИмяКолонкиЗамещения = Неопределено) Экспорт
	Сериализатор = Плагин("СериализаторMXL");
	Возврат Сериализатор.СоздатьДанныеПоТабличномуДокументу(ТабличныйДокументИлиМассивТабличныхДокументов, РежимыЗагрузкиИлиИмяКолонкиЗамещения, ИмяКолонкиЗамещения);
КонецФункции

// удаляет созданные элементы (Справочники, Документы, Пользователи ИБ), регистры сведений не чистит - есть тесты
Функция УдалитьСозданныеДанные(Данные) Экспорт
	Сериализатор = Плагин("СериализаторMXL");
	Возврат Сериализатор.УдалитьСозданныеДанные(Данные);
КонецФункции

// }

//{ Чтение JSON файла

Функция ПолучитьИмяПараметра(ТаблицаЗначенийИзФайла,СтрокаИзФайла,СчетчикСтрок,ПозицияВСтроке)
	Стр = "";

	КолСимволов = СтрДлина(СтрокаИзФайла);
	Пока Истина Цикл
		ПозицияВСтроке = ПозицияВСтроке + 1;
		Если ПозицияВСтроке > КолСимволов Тогда
			Прервать;
		КонецЕсли;
		Символ = Сред(СтрокаИзФайла,ПозицияВСтроке,1);

		Если Символ = """" Тогда
			Прервать;
		КонецЕсли;

		Стр = Стр + Символ;
	КонецЦикла;

	Возврат Стр;
КонецФункции

Функция ПрочитатьСтруктуруИзJSON(ТаблицаЗначенийИзФайла, СчетчикСтрок, ПозицияВСтроке, Результат, ЧитатьВСоответствие)

	Если ЧитатьВСоответствие Тогда
		СтруктураДляЗаполнения = Новый Соответствие;
	Иначе
		СтруктураДляЗаполнения = Новый Структура;
	КонецЕсли;

	Пока Истина Цикл
		ПозицияВСтроке = 0;
		СчетчикСтрок = СчетчикСтрок + 1;
		Если СчетчикСтрок > (ТаблицаЗначенийИзФайла.Количество() - 1) Тогда
			Прервать;
		КонецЕсли;
		Стр = ТаблицаЗначенийИзФайла[СчетчикСтрок].Стр;
		Если Лев(Стр, 1) = "}" Тогда
			Прервать;
		КонецЕсли;
		ОбработатьСтроку(ТаблицаЗначенийИзФайла, ТаблицаЗначенийИзФайла[СчетчикСтрок].Стр, СчетчикСтрок, ПозицияВСтроке, Результат, СтруктураДляЗаполнения, ЧитатьВСоответствие);
	КонецЦикла;

	Возврат СтруктураДляЗаполнения;

КонецФункции

Функция ПрочитатьМассивИзJSON(ТаблицаЗначенийИзФайла, СчетчикСтрок, ПозицияВСтроке, Результат, ЧитатьВСоответствие)

	СтруктураДляЗаполнения = Новый Массив;

	Пока Истина Цикл
		ПозицияВСтроке = 0;
		СчетчикСтрок = СчетчикСтрок + 1;
		Если СчетчикСтрок > (ТаблицаЗначенийИзФайла.Количество() - 1) Тогда
			Прервать;
		КонецЕсли;

		Стр = ТаблицаЗначенийИзФайла[СчетчикСтрок].Стр;
		Если Лев(Стр, 1) = "]" Тогда
			Прервать;
		КонецЕсли;

		Если Прав(Стр, 1) = "," Тогда
			Стр = Лев(Стр, СтрДлина(Стр) - 1);
		КонецЕсли;

		Если Лев(Стр, 1) = "{" Тогда
			Значение = ПрочитатьСтруктуруИзJSON(ТаблицаЗначенийИзФайла, СчетчикСтрок, ПозицияВСтроке, Результат, ЧитатьВСоответствие);
			СтруктураДляЗаполнения.Добавить(Значение);
			Продолжить;
		КонецЕсли;

		Стр = УбратьЛишниеКавычки(Стр);
		СтруктураДляЗаполнения.Добавить(Стр);
	КонецЦикла;

	Возврат СтруктураДляЗаполнения;

КонецФункции

Функция ПолучитьЗначениеИзJSON(ТаблицаЗначенийИзФайла, СтрокаИзФайла, СчетчикСтрок, ПозицияВСтроке, Результат, ЧитатьВСоответствие)

	Значение = "";
	КолСимволов = СтрДлина(СтрокаИзФайла);

	// Пропускаем проблелы
	Пока Истина Цикл
		ПозицияВСтроке = ПозицияВСтроке + 1;
		Если ПозицияВСтроке > КолСимволов Тогда
			Прервать;
		КонецЕсли;
		Символ = Сред(СтрокаИзФайла, ПозицияВСтроке, 1);

		Если Символ = " " Тогда
			Продолжить;
		Иначе
			Прервать;
		КонецЕсли;
	КонецЦикла;

	// Сейчас мы на первом не пустом символе
	БылОдинСтроковыйСимвол = Ложь;
	ПозицияВСтроке = ПозицияВСтроке - 1;
	Пока Истина Цикл
		ПозицияВСтроке = ПозицияВСтроке + 1;
		Если ПозицияВСтроке > КолСимволов Тогда
			Прервать;
		КонецЕсли;
		Символ = Сред(СтрокаИзФайла, ПозицияВСтроке, 1);

		Если НЕ БылОдинСтроковыйСимвол Тогда
			Если Символ = "{" Тогда
				Значение = ПрочитатьСтруктуруИзJSON(ТаблицаЗначенийИзФайла, СчетчикСтрок, ПозицияВСтроке, Результат, ЧитатьВСоответствие);
				Прервать;
			ИначеЕсли Символ = "[" Тогда
				Если Сред(СтрокаИзФайла, ПозицияВСтроке+1, 1) = "]" Тогда
					//значит это пустой массив
					Значение = Новый Массив;
					Прервать;
				КонецЕсли;
				Значение = ПрочитатьМассивИзJSON(ТаблицаЗначенийИзФайла, СчетчикСтрок, ПозицияВСтроке, Результат, ЧитатьВСоответствие);
				Прервать;
			КонецЕсли;
		КонецЕсли;

		Если ПозицияВСтроке = КолСимволов Тогда // значит это последний символ в строке
			Если Символ = "," Тогда
				Продолжить;
			КонецЕсли;
		КонецЕсли;

		Значение = Значение + Символ;

		БылОдинСтроковыйСимвол = Истина;

	КонецЦикла;

	Значение = УбратьЛишниеКавычки(Значение);

	Возврат Значение;

КонецФункции

Функция УбратьЛишниеКавычки(Знач Значение)

	Если (Лев(Значение, 1) = "'") И (Прав(Значение, 1) = "'") Тогда
		Значение = Сред(Значение, 2, СтрДлина(Значение) - 2);
	КонецЕсли;

	Если (Лев(Значение, 1) = """") И (Прав(Значение, 1) = """") Тогда
		Значение = Сред(Значение, 2, СтрДлина(Значение) - 2);
	КонецЕсли;

	Возврат Значение;

КонецФункции

Процедура ОбработатьСтроку(ТаблицаЗначенийИзФайла, СтрокаИзФайла, СчетчикСтрок, ПозицияВСтроке, Результат, СтруктураДляЗаполнения, ЧитатьВСоответствие)

	КолСимволов = СтрДлина(СтрокаИзФайла);
	Пока Истина Цикл
		ПозицияВСтроке = ПозицияВСтроке + 1;
		Если ПозицияВСтроке > КолСимволов Тогда
			Прервать;
		КонецЕсли;
		Символ = Сред(СтрокаИзФайла, ПозицияВСтроке, 1);

		Если Символ = "{" Тогда
			Если Результат = Неопределено Тогда
				Если ЧитатьВСоответствие Тогда
					Результат              = Новый Соответствие;
				Иначе
					Результат              = Новый Структура;
				КонецЕсли;
				СтруктураДляЗаполнения = Результат;
			КонецЕсли;
		ИначеЕсли Символ = "}" Тогда
		ИначеЕсли Символ = """" Тогда
			ТекИмя = ПолучитьИмяПараметра(ТаблицаЗначенийИзФайла, СтрокаИзФайла, СчетчикСтрок, ПозицияВСтроке);
		ИначеЕсли Символ = ":" Тогда
			Значение = ПолучитьЗначениеИзJSON(ТаблицаЗначенийИзФайла, СтрокаИзФайла, СчетчикСтрок, ПозицияВСтроке, Результат, ЧитатьВСоответствие);
			Если ТипЗнч(Значение) = Тип("Строка") Тогда
				Значение = СтрЗаменить(Значение, "'", "");
			КонецЕсли;
			СтруктураДляЗаполнения.Вставить(ТекИмя, Значение);
			Прервать;
		Иначе
			Сообщить("Ошибка чтения JSON! Неизвестный символ " + Символ);
			Возврат;
		КонецЕсли;
	КонецЦикла;

КонецПроцедуры

Функция ПрочитатьСтруктуруИзJSONФайла(ИмяФайлаVBParams, ПараметрыУФ = Неопределено) Экспорт

	Если ПараметрыУФ = Неопределено Тогда
		ИмяФайла = ИмяФайлаVBParams;
	Иначе
		VBParamsДвоичныеДанные = ПараметрыУФ.VBParamsДвоичныеДанные;
		ИмяФайла               = ПолучитьИмяВременногоФайла("json");
		VBParamsДвоичныеДанные.Записать(ИмяФайла);
	КонецЕсли;

	ВремНастройкиСоответствие = ПрочитатьНастройкиИзФайлаJSon(ИмяФайла);
	Возврат ВремНастройкиСоответствие;

КонецФункции

Функция ПрочитатьНастройкиИзФайлаJSon(Знач ПутьФайлаНастроек)
	Результат = Новый Структура();
	ФайлНастроек = Новый Файл(ПутьФайлаНастроек);
	Если ФайлНастроек.Существует() Тогда
		ЧтениеJSON = Новый ЧтениеJSON;
		ЧтениеJSON.ОткрытьФайл(ПутьФайлаНастроек);

		Соответствие = ПрочитатьJSON(ЧтениеJSON, Истина);
		Результат = ПреобразоватьСоответствиеВСтруктуру(Соответствие, КоллекцияИсключаемыхКлючей());
	КонецЕсли;
	Возврат Результат;
КонецФункции

Функция ПреобразоватьСоответствиеВСтруктуру(Знач Соответствие, Знач КоллекцияИсключаемыхКлючей)
	Результат = Новый Структура;
	Для каждого КлючЗначение Из Соответствие Цикл
		Если КоллекцияИсключаемыхКлючей.Получить(КлючЗначение.Ключ) = Неопределено Тогда
			Значение = КлючЗначение.Значение;
			Если ТипЗнч(Значение) = Тип("Соответствие") Тогда
				Значение = ПреобразоватьСоответствиеВСтруктуру(Значение, КоллекцияИсключаемыхКлючей);
			КонецЕсли;
			Результат.Вставить(КлючЗначение.Ключ, Значение);
		КонецЕсли;
	КонецЦикла;
	Возврат Результат;
КонецФункции

Функция КоллекцияИсключаемыхКлючей()
	КоллекцияИсключаемыхКлючей = Новый Соответствие;
	КоллекцияИсключаемыхКлючей.Вставить("$schema", "$schema");
	Возврат КоллекцияИсключаемыхКлючей;
КонецФункции

// }

Процедура ЗапретитьВыполнениеШагов() Экспорт
	ХостФорма = ПолучитьФорму("Форма");
	ХостФорма.ЗапретитьВыполнениеШаговФорма();
КонецПроцедуры

Процедура ПродолжитьВыполнениеШагов(ШагУпал = Ложь) Экспорт
	ХостФорма = ПолучитьФорму("Форма");
	ХостФорма.ПродолжитьВыполнениеШаговФорма(ШагУпал);
КонецПроцедуры

Процедура ОбойтиДеревоДляВнутреннегоФормата(Дерево, ТабличныйДокумент, Макет, Интервал, ПараметрыОтчетаУФ)

	Для каждого СтрСтроки Из Дерево.Строки Цикл
		Секция = Неопределено;
		Сценарий = Новый Структура("имя, name, start, stop, message, status");
		Если СтрСтроки.Тип = "Каталог" Тогда
			Секция = макет.ПолучитьОбласть("Заголовок");
		ИначеЕсли СтрСтроки.Тип = "Фича" Тогда
			Секция = макет.ПолучитьОбласть("Заголовок");
		ИначеЕсли СтрСтроки.Тип = "Шаг" Тогда
			Секция = макет.ПолучитьОбласть("Шаг");
		Иначе
			Секция = макет.ПолучитьОбласть("Заголовок");
		КонецЕсли;
		Если СтрСтроки.Тип = "Пример" Тогда
			Сценарий.name     = СтрСтроки.Родитель.Родитель.Имя + " №" + (СтрСтроки.Родитель.Строки.Индекс(СтрСтроки));
		Иначе
			Сценарий.name     = СтрСтроки.Имя;
		КонецЕсли;
		Сценарий.Имя = Интервал + СтрСтроки.Имя;

		Если СтрСтроки.Статус = "Failed" И НЕ СтрСтроки.Сценарий Тогда
			ИДВМассиве                         = ПараметрыОтчетаУФ.МассивИДСтрокиДерева.Найти(СтрСтроки.Родитель.ИДСтроки);
			Если ИДВМассиве <> Неопределено Тогда
				РезультатПрохожденияТестовСценария = ПараметрыОтчетаУФ.МассивРезультатПрохожденияТестовСценария[ИДВМассиве];
			КонецЕсли;
		КонецЕсли;

		Если РезультатПрохожденияТестовСценария <> Неопределено Тогда
			Сценарий.start = РезультатПрохожденияТестовСценария.ВремяНачала - РазницаВМилисекундахМеждуЮниксИНачалЭпохи;;
			Сценарий.stop  = РезультатПрохожденияТестовСценария.ВремяОкончания - РазницаВМилисекундахМеждуЮниксИНачалЭпохи;;
			Сценарий.message = РезультатПрохожденияТестовСценария.ОписаниеОшибки;
		КонецЕсли;

		Секция.Параметры.Заполнить(Сценарий);
		ТабличныйДокумент.Вывести(Секция);
		Если СтрСтроки.Статус = "Failed" И НЕ СтрСтроки.Сценарий Тогда
			Секция = макет.ПолучитьОбласть("Ошибка");
			Секция.Параметры.Заполнить(Сценарий);
			ТабличныйДокумент.Вывести(Секция);
		КонецЕсли;

		Если СтрСтроки.Строки.Количество() > 0 Тогда
			ТабличныйДокумент.НачатьАвтогруппировкуСтрок();
			ОбойтиДеревоДляВнутреннегоФормата(СтрСтроки, ТабличныйДокумент, Макет, Интервал + "   ", ПараметрыОтчетаУФ);
			ТабличныйДокумент.ЗакончитьАвтогруппировкуСтрок();
		КонецЕсли;
	КонецЦикла;

КонецПроцедуры

Функция ВывестиОтчетТестированияВоВнутреннемФормате(Дерево, ПараметрыОтчетаУФ) Экспорт

	ТабДок = Новый ТабличныйДокумент;
	макет = ПолучитьМакет("ОтчетТестирования");

	Секция = макет.ПолучитьОбласть("Заголовок");

	Интервал = "";
	ОбойтиДеревоДляВнутреннегоФормата(Дерево, ТабДок, Макет, Интервал + "   ", ПараметрыОтчетаУФ);

	ТабДок.ОтображатьСетку = Ложь;
	ТабДок.Защита = Ложь;
	ТабДок.ТолькоПросмотр = Ложь;
	ТабДок.ОтображатьЗаголовки = Ложь;

	Возврат ТабДок;

КонецФункции

Процедура Шаг(Стр) Экспорт
	ХостФорма = ПолучитьФорму("Форма");
	ХостФорма.ШагФорма(Стр);
КонецПроцедуры

Процедура СоздатьКолонкиДерева(Дерево) Экспорт
	Дерево.Колонки.Добавить("Имя");
	Дерево.Колонки.Добавить("Статус");
	Дерево.Колонки.Добавить("ПолныйПуть");
	Дерево.Колонки.Добавить("ИменованныеПараметры");
	Дерево.Колонки.Добавить("ЗначенияПараметров");
	Дерево.Колонки.Добавить("Снипет");
	Дерево.Колонки.Добавить("АдресСнипета");
	Дерево.Колонки.Добавить("ЭтоЧужойСнипет");
	Дерево.Колонки.Добавить("СтрокаРеальнойПроцедуры");

	Дерево.Колонки.Добавить("РезультатПрохожденияТестовСценария");

	Дерево.Колонки.Добавить("ШагСПараметрамиВТаблице");
	Дерево.Колонки.Добавить("СтрокаПараметровШагаВВидеТаблицы");
	Дерево.Колонки.Добавить("ПараметрыТаблицы");
	Дерево.Колонки.Добавить("ИмяШагаБезКлючевогоСлова");
	Дерево.Колонки.Добавить("ШагСценарий");
	Дерево.Колонки.Добавить("МассивСценариевЗащитаОтЗацикливания");
	Дерево.Колонки.Добавить("ФичаИмеетСвоюEPF");
	Дерево.Колонки.Добавить("МассивТегов");
	Дерево.Колонки.Добавить("НомерСтрокиВФиче");

	Если Дерево.Колонки.Найти("ТипКартинки") = Неопределено Тогда
		Дерево.Колонки.Добавить("ТипКартинки");
	КонецЕсли;

	Дерево.Колонки.Добавить("ЗначениеОтступа",Новый ОписаниеТипов("Число"));
	Дерево.Колонки.Добавить("Тип",Новый ОписаниеТипов("Строка"));
	Дерево.Колонки.Добавить("ДопТип",Новый ОписаниеТипов("Строка"));
	Дерево.Колонки.Добавить("ДополнительныеДанные");

КонецПроцедуры

Процедура ДобавитьШагВМассивТестов(МассивТестов, Снипет, ИмяПроцедуры, ПредставлениеТеста = Неопределено,
		ОписаниеШага = Неопределено, ТипШагаДляОписания = Неопределено, ТипШагаВДереве = Неопределено) Экспорт

	Структура = Новый Структура;

	Структура.Вставить("Снипет", Снипет);
	Структура.Вставить("ИмяПроцедуры", ИмяПроцедуры);
	Структура.Вставить("ПредставлениеТеста", ПредставлениеТеста);
	Структура.Вставить("ОписаниеШага", ОписаниеШага);
	Структура.Вставить("ТипШага", ТипШагаДляОписания);
	Структура.Вставить("ТипШагаВДереве", ТипШагаВДереве);
	МассивТестов.Добавить(Структура);
КонецПроцедуры

Функция ПрочитатьКоллекциюИзJSONФайла(ИмяФайла, ЧитатьВСоответствие = Ложь)
	Перем Результат;

	Результат              = Неопределено;
	СтруктураДляЗаполнения = Неопределено;
	ТекЗначение            = Неопределено;

	ЕстьЧтениеJSON = Ложь;
	Попытка
		ЧтениеJSON = Вычислить("Новый ЧтениеJSON");
	    ЕстьЧтениеJSON = Истина;
	Исключение
	КонецПопытки;

	Если ЕстьЧтениеJSON Тогда
		ЧтениеJSON = Вычислить("Новый ЧтениеJSON");
		ЧтениеJSON.ОткрытьФайл(ИмяФайла);
		Выполнить("Результат = ПрочитатьJSON(ЧтениеJSON, ЧитатьВСоответствие)");
	Иначе

		ТаблицаЗначенийИзФайла = Новый ТаблицаЗначений;
		ТаблицаЗначенийИзФайла.Колонки.Добавить("Стр");

		Текст = Новый ЧтениеТекста;
		Текст.Открыть(ИмяФайла, "UTF-8");

		ТекИмя = Неопределено;
		Пока Истина Цикл
			Стр = Текст.ПрочитатьСтроку();
			Если Стр = Неопределено Тогда
				Прервать;
			КонецЕсли;

			Стр = СокрЛП(Стр);
			Если Стр = "" Тогда
				Продолжить;
			КонецЕсли;

			Стр = СтрЗаменить(Стр, "\""", """");
			Стр = СтрЗаменить(Стр, "\\", "\");

			СтрТаблицаЗначенийИзФайла     = ТаблицаЗначенийИзФайла.Добавить();
			СтрТаблицаЗначенийИзФайла.Стр = Стр;
		КонецЦикла;

		Текст.Закрыть();

		СчетчикСтрок = -1;
		Пока Истина Цикл
			СчетчикСтрок = СчетчикСтрок + 1;
			Если СчетчикСтрок > (ТаблицаЗначенийИзФайла.Количество() - 1) Тогда
				Прервать;
			КонецЕсли;

			ПозицияВСтроке = 0;
			ОбработатьСтроку(ТаблицаЗначенийИзФайла, ТаблицаЗначенийИзФайла[СчетчикСтрок].Стр, СчетчикСтрок, ПозицияВСтроке, Результат, СтруктураДляЗаполнения, ЧитатьВСоответствие);
		КонецЦикла;
	КонецЕсли;

	Возврат Результат;

КонецФункции

// Функция - Прочитать соответствие из JSON-файла
// Предназначена для чтения данных из JSON-файла в коллекцию типа Соответствие
//
// Параметры:
//  ДанныеJSON	 - ДвоичныеДанные	 - двоичные данные файла JSON;
//  			 - Структура		 - структура параметров VB со свойством VBParamsДвоичныеДанные.
//  								   Для совместимости со старым методом;
//  			 - Строка			 - путь в файлу JSON
//
// Возвращаемое значение:
//  Соответствие - коллекция значений из JSON-файла
//
Функция ПрочитатьСоответствиеИзJSONФайла(ДанныеJSON) Экспорт

		// Если параметром переданые двоичные данные, то записываем их во временный файл
	Если ТипЗнч(ДанныеJSON) = Тип("ДвоичныеДанные") Тогда
		ИмяФайла               = ПолучитьИмяВременногоФайла("json");
		ДанныеJSON.Записать(ИмяФайла);
	// Если параметром передана структура с параметрами VB,
	// то берем двоичные данные из свойства "VBParamsДвоичныеДанные"
	ИначеЕсли ТипЗнч(ДанныеJSON) = Тип("Структура") Тогда
		JSONДвоичныеДанные = ДанныеJSON.VBParamsДвоичныеДанные;
		ИмяФайла               = ПолучитьИмяВременногоФайла("json");
		JSONДвоичныеДанные.Записать(ИмяФайла);
	// Если параметром передана строка, то считаем, что это путь к файлу JSON
	ИначеЕсли ТипЗнч(ДанныеJSON) = Тип("Строка") Тогда
		ИмяФайла = ДанныеJSON;
	КонецЕсли;

	Возврат ПрочитатьКоллекциюИзJSONФайла(ИмяФайла, Истина);

КонецФункции

Процедура УстановитьРезультатУсловия(Результат) Экспорт
	РезультатУсловия = Результат;
КонецПроцедуры

// { режим совместимости 8.3.5

// Аналог СтрРазделить() для старых версий платформы
// Описание параметров аналогично описанию параметров для СтрРазделить()
Функция РазложитьСтрокуВМассивПодстрок(Знач Строка, Знач Разделитель = ",", Знач ПропускатьПустыеСтроки = Неопределено) Экспорт

	Результат = Новый Массив;

	// для обеспечения обратной совместимости
	Если ПропускатьПустыеСтроки = Неопределено Тогда
		ПропускатьПустыеСтроки = ?(Разделитель = " ", Истина, Ложь);
		Если ПустаяСтрока(Строка) Тогда
			Если Разделитель = " " Тогда
				Результат.Добавить("");
			КонецЕсли;
			Возврат Результат;
		КонецЕсли;
	КонецЕсли;

	Позиция = Найти(Строка, Разделитель);
	Пока Позиция > 0 Цикл
		Подстрока = Лев(Строка, Позиция - 1);
		Если Не ПропускатьПустыеСтроки Или Не ПустаяСтрока(Подстрока) Тогда
			Результат.Добавить(Подстрока);
		КонецЕсли;
		Строка = Сред(Строка, Позиция + СтрДлина(Разделитель));
		Позиция = Найти(Строка, Разделитель);
	КонецЦикла;

	Если Не ПропускатьПустыеСтроки Или Не ПустаяСтрока(Строка) Тогда
		Результат.Добавить(Строка);
	КонецЕсли;

	Возврат Результат;

КонецФункции

&НаКлиенте
Функция СтрСоединить_(МассивЭлементов, Символ = "") Экспорт
	СтрокаРезультат = "";
	Если МассивЭлементов.Количество() > 0 Тогда
		СтрокаРезультат = МассивЭлементов.Получить(0) + Символ;
		Для сч = 0 по МассивЭлементов.ВГраница() Цикл
			Элемент = МассивЭлементов.Получить(сч);
			Если ЗначениеЗаполнено(Элемент) Тогда
				СтрокаРезультат = МассивЭлементов.Получить(сч) + Символ;
			КонецЕсли;
		КонецЦикла;
	КонецЕсли;

	Возврат СтрокаРезультат;

КонецФункции

// Замена функции СтрШаблон на конфигурациях с режимом совместимости < 8.3.6
// При внедрении в конфигурацию с режимом совместимости >= 8.3.6 данную функцию необходимо удалить
//
&НаКлиенте
Функция СтрШаблон_(Знач СтрокаШаблон, Знач Парам1 = Неопределено, Знач Парам2 = Неопределено, Знач Парам3 = Неопределено, Знач Парам4 = Неопределено) Экспорт

	МассивПараметров = Новый Массив;
	МассивПараметров.Добавить(Парам1);
	МассивПараметров.Добавить(Парам2);
	МассивПараметров.Добавить(Парам3);
	МассивПараметров.Добавить(Парам4);

	Для Сч = 1 По МассивПараметров.Количество() Цикл
		ТекЗначение = МассивПараметров[Сч-1];
		СтрокаШаблон = СтрЗаменить(СтрокаШаблон, "%"+Сч, Строка(ТекЗначение));
	КонецЦикла;
	Возврат СтрокаШаблон;
КонецФункции

// }

#Область Версии_и_РежимСовместимости

Функция ВерсияПриложенияБольшеИлиРавнаЧемЗаданная(Версия1, Версия2) Экспорт
	Массив1 = РазложитьСтрокуВМассивПодстрок(Версия1, ".");
	Массив2 = РазложитьСтрокуВМассивПодстрок(Версия2, ".");

	Версия1БольшеИлиРавно = Истина;
	Для Ккк = 0 По Мин(Массив1.Количество(), Массив2.Количество()) - 1 Цикл
		Элем1 = Массив1.Получить(Ккк);
		Элем2 = Массив2.Получить(Ккк);

		Если Число(Элем2) > Число(Элем1) Тогда
			Версия1БольшеИлиРавно = Ложь;
		ИначеЕсли Число(Элем2) < Число(Элем1) Тогда
			Прервать;
		КонецЕсли;
	КонецЦикла;

	Возврат Версия1БольшеИлиРавно;
КонецФункции

Функция ПодходящийРежимСовместимостиПлатформы(Знач НеобходимаяВерсияПриложения) Экспорт

	СистемнаяИнформация = Новый СистемнаяИнформация;
	Если Не ВерсияПриложенияБольшеИлиРавнаЧемЗаданная(СистемнаяИнформация.ВерсияПриложения, НеобходимаяВерсияПриложения) Тогда
		Возврат Ложь;
	КонецЕсли;

	ВерсияРежимаСовместимости = ВерсияРежимаСовместимости();

	Возврат ВерсияПриложенияБольшеИлиРавнаЧемЗаданная(ВерсияРежимаСовместимости, НеобходимаяВерсияПриложения);

КонецФункции

Функция ВерсияРежимаСовместимости(Знач ЗначениеПоУмолчанию = Неопределено) Экспорт

	Если Не ЗначениеЗаполнено(КешВерсияРежимСовместимости) Тогда
		РежимСовместимостиВерсия = СтрЗаменить(РежимСовместимости(ЗначениеПоУмолчанию), "Версия", "");
		КешВерсияРежимСовместимости = СтрЗаменить(РежимСовместимостиВерсия, "_", ".");
	КонецЕсли;

	Возврат КешВерсияРежимСовместимости;

КонецФункции

Функция РежимСовместимости(Знач ЗначениеПоУмолчанию = Неопределено) Экспорт

	Если Не ЗначениеЗаполнено(КешРежимСовместимости) Тогда

		Если ЗначениеПоУмолчанию = Неопределено Тогда
			ЗначениеПоУмолчанию = Метаданные.СвойстваОбъектов.РежимСовместимости.НеИспользовать;;
		КонецЕсли;

		Попытка
			КешРежимСовместимости = Вычислить("Метаданные.РежимСовместимости");
		Исключение
			КешРежимСовместимости = ЗначениеПоУмолчанию;
		КонецПопытки;

	КонецЕсли;

	Возврат КешРежимСовместимости;

КонецФункции

// Функция - Это линукс
//
// Возвращаемое значение:
//   Булево - Линукс или нет
//
Функция ЭтоЛинукс() Экспорт

	Возврат ЭтоLinux;

КонецФункции

#КонецОбласти

СтатусыРезультатаТестирования = Новый Структура;
СтатусыРезультатаТестирования.Вставить("ОшибкаПроверки", "Failed");
СтатусыРезультатаТестирования.Вставить("НеизвестнаяОшибка", "Broken");
СтатусыРезультатаТестирования.Вставить("ТестПропущен", "Pending");
СтатусыРезультатаТестирования = Новый ФиксированнаяСтруктура(СтатусыРезультатаТестирования);

РезультатыСравненияТаблиц = Новый Структура;
РезультатыСравненияТаблиц.Вставить("ТаблицыСовпадают", 0);
РезультатыСравненияТаблиц.Вставить("НеСовпадаютЗначенияВЯчейкеТаблицы", 1);
РезультатыСравненияТаблиц.Вставить("РазноеКоличествоСтрок", 2);
РезультатыСравненияТаблиц.Вставить("РазличаютсяКолонки", 3);
РезультатыСравненияТаблиц = Новый ФиксированнаяСтруктура(РезультатыСравненияТаблиц);

СисИнфо = Новый СистемнаяИнформация;
ЭтоLinux = (Найти(Строка(СисИнфо.ТипПлатформы), "Linux") > 0);

ТипыПлагинов = ТипыПлагинов();

РазницаВМилисекундахМеждуЮниксИНачалЭпохи = 62135596800000;