engine-behaviors.os

///////////////////////////////////////////////////////////////////////
//
// Тест проверки поведения движка
//
///////////////////////////////////////////////////////////////////////

Перем юТест;
Перем глТестоваяПеременная;

////////////////////////////////////////////////////////////////////
// Программный интерфейс

Функция ПолучитьСписокТестов(ЮнитТестирование) Экспорт

	юТест = ЮнитТестирование;

	ВсеТесты = Новый Массив;

	ВсеТесты.Добавить("ТестДолжен_ПроверитьЗаполненностьЗначений");
	ВсеТесты.Добавить("ТестДолженПроверитьИсключенияИдущиеДругЗаДругом");
	ВсеТесты.Добавить("ТестДолжен_ВызватьФункциюКакПроцедуру_Issue104");
	ВсеТесты.Добавить("ТестДолжен_ПрочитатьЛитералДатыСРазделителями");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьПерекрытиеГлобальнойПеременнойВнутриМетода");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьРазыменованияВПравойЧастиВыражения");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьУстановкуЗначенияПоСсылке");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьСокращенноеВычислениеПоИ");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьСокращенноеВычислениеПоИЛИ");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьВычислениеНЕ");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьОператорВопросаПоИстина");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьОператорВопросаПоЛожь");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьМаршаллингУникальныхИдентификаторовИПеречислений");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьВложенностьПробрасываемыхИсключений");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьКомпиляциюОбращенияКВозвращаемомуОбъектуЧерезТочку");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьРаботуФункцииТРег");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоПараметрОтмеченныйЗнач_НеМеняется");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоИзФункцииВозвращаютсяРазныеЗначения");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоПослеЛогическогоОператораВыполняетсяПовторОперацииСВысокимПриоритетом_Ошибка184");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоПослеЛогическогоОператораОбрываетсяЦепочкаПриОперацииСНизкимПриоритетом_Ошибка184");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьПриоритетОператораНЕПередОперациейСравнения");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоВозможныПараметризованныеИсключения");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоВозможноИспользоватьПараметрыОбычногоИсключения");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьПередачуПеречисленийЧерезПараметры");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьКомпиляциюКлючевыхСловВСвойствахСтруктуры");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоАргументыКоманднойСтрокиЭтоФиксированныйМассив");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьЗагрузкуСкриптаИзСтроки");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьПропускПараметров");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьФинальнуюЗапятуюВОбъявленииМетода");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьВозможностьРазыменованияПослеТернарногоОператора");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьМинусВЗначенииПарамераПоУмолчанию");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьПрерываниеВложенныхПопыток");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьПродолжениеВложенныхПопыток");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьИнформацияОбОшибкеВнеИсключения");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьПередачуПараметровПоСсылке");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьСравнениеНаБольшеМеньше");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьЧто_ЭтотОбъект_НедоступенДляЗаписи");
	
	ВсеТесты.Добавить("ТестДолжен_ПроверитьОперацииСДатой_Сложение");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьОперацииСДатой_Вычитание");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьОперацииСДатой_СложениеДат");
	
	ВсеТесты.Добавить("ТестДолжен_ПроверитьВложенныеИсключения");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьВложенныеИсключенияДелегат");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьВложенныеИсключенияФоновоеЗадание");

	Возврат ВсеТесты;

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

Процедура ТестДолженПроверитьИсключенияИдущиеДругЗаДругом() Экспорт
	Попытка
		БроситьИсключение(1, 2);
	Исключение
		юТест.ТестПройден();
		Возврат;
	КонецПопытки;

	юТест.ТестПровален("Ожидаемое исключение не возникло.");		
КонецПроцедуры

Процедура БроситьИсключение(Парам1, Парам2)
	Попытка
		ВызватьИсключение Парам1;
	Исключение
	КонецПопытки;

	ВызватьИсключение Парам2;
КонецПроцедуры

Функция ВызовЛомающийСтек()

	Если ЗначениеЗаполнено(0) Тогда
		А = 2;
	КонецЕсли;

    Возврат 1;

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

Функция НекаяФункция()
	ВызовЛомающийСтек();
	Возврат 1;
КонецФункции

Функция ПерекрытаяГлТестоваяПеременная()
	Перем глТестоваяПеременная;
	глТестоваяПеременная = "new";
	Возврат глТестоваяПеременная;
КонецФункции

Процедура ТестДолжен_ВызватьФункциюКакПроцедуру_Issue104() Экспорт

	юТест.ПроверитьРавенство(1, НекаяФункция()); // сбой передачи аргумента в метод.

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

Процедура ТестДолжен_ПрочитатьЛитералДатыСРазделителями() Экспорт

	юТест.ПроверитьРавенство('20140101121727', '2014-01-01 12:17:27');
	юТест.ПроверитьРавенство('20140101121727', '2014 год 01 месяц 01 число 12 часов 17 минут 27 секунд');

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

Процедура ТестДолжен_ПроверитьПерекрытиеГлобальнойПеременнойВнутриМетода() Экспорт
	глТестоваяПеременная = 1;
	ПерекрытаяГлТестоваяПеременная = ПерекрытаяГлТестоваяПеременная();

	юТест.ПроверитьРавенство(1, глТестоваяПеременная, "Глобальная переменная не должна поменять значение");
	юТест.ПроверитьРавенство("new", ПерекрытаяГлТестоваяПеременная, "Локальная переменная с таким же именем получена корректно");

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

Функция ФункцияВозвращаетОбъект()
	Возврат Новый Структура;
КонецФункции

Процедура ТестДолжен_ПроверитьРазыменованияВПравойЧастиВыражения() Экспорт

	Объект = Новый Структура("Свойство1",
				Новый Структура("Свойство2",
					Новый Структура("Свойство3", 1)
				)
			);
	А = Объект.Свойство1.Свойство2.Свойство3;
	юТест.ПроверитьРавенство(1, А);

	Массив = Новый Массив;
	Массив.Добавить((Объект.Свойство1.Свойство2));

	Объект.Свойство1 = Массив;
	Массив[0].Свойство3 = 2;
	юТест.ПроверитьРавенство(2, Объект.Свойство1[0].Свойство3);

	Массив[0] = Новый Массив;
	Массив[0].Добавить(0);

	юТест.ПроверитьРавенство(0, Массив[0][0]);
	юТест.ПроверитьРавенство(Массив[0], Массив[Массив[0][0]]);

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

Процедура ТестДолжен_ПроверитьУстановкуЗначенияПоСсылке() Экспорт

	Массив = Новый Массив;
	Массив.Добавить(5);
	ТестоваяПроцедура_УстановитьПоСсылке(Массив[0]);
	юТест.ПроверитьРавенство("НОВОЕЗНАЧЕНИЕ", Массив[0]);

	Массив.Добавить(Новый Структура("Свойство1", 7));
	ТестоваяПроцедура_УстановитьПоСсылке(Массив[1].Свойство1);
	юТест.ПроверитьРавенство("НОВОЕЗНАЧЕНИЕ", Массив[1].Свойство1);

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

Функция ТестоваяПроцедура_УстановитьПоСсылке(Параметр)
	Параметр = "НОВОЕЗНАЧЕНИЕ";
	Возврат Истина;
КонецФункции

Процедура ТестДолжен_ПроверитьСокращенноеВычислениеПоИ() Экспорт

	А = 5;
	Если Ложь или Истина и Ложь И ТестоваяПроцедура_УстановитьПоСсылке(А) Тогда
	КонецЕсли;

	юТест.ПроверитьРавенство(5, А);

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

Процедура ТестДолжен_ПроверитьСокращенноеВычислениеПоИЛИ() Экспорт

	А = 5;
	Если Истина или Истина и Ложь или ТестоваяПроцедура_УстановитьПоСсылке(А) Тогда
	КонецЕсли;

	юТест.ПроверитьРавенство(5, А);

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

Процедура ТестДолжен_ПроверитьВычислениеНЕ() Экспорт
	ТипСтроки = Тип("Строка");
	Операнд = 100;

	Если Не ТипЗнч(Операнд) = ТипСтроки И Ложь Тогда
		ВызватьИсключение "Операция НЕ должна быть выполнена до любого другого логического оператора";
	КонецЕсли;

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

Процедура ТестДолжен_ПроверитьОператорВопросаПоИстина() Экспорт
	А = 5;
	юТест.ПроверитьЛожь(?(Истина,Ложь,ТестоваяПроцедура_УстановитьПоСсылке(А)));
	юТест.ПроверитьРавенство(5, А);
КонецПроцедуры

Процедура ТестДолжен_ПроверитьОператорВопросаПоЛожь() Экспорт
	А = 5;
	юТест.ПроверитьЛожь(?(Ложь,ТестоваяПроцедура_УстановитьПоСсылке(А),Ложь));
	юТест.ПроверитьРавенство(5, А);
КонецПроцедуры

Процедура ТестДолжен_ПроверитьМаршаллингУникальныхИдентификаторовИПеречислений() Экспорт

	ИД = Новый УникальныйИдентификатор();
	Перечисление = ТипУзлаXML.НачалоЭлемента;
	Приемник = Новый Соответствие;

	Приемник[ИД] = Истина;
	Приемник[Перечисление] = Истина;

	// не должно упасть

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

Процедура ПроброситьИсключение()

	Попытка
		ВызватьИсключение "Первое";
	Исключение
		Попытка
			А = 1;
		Исключение
			ВызватьИсключение "Второе";
		КонецПопытки;
		ВызватьИсключение;
	КонецПопытки;

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


Процедура ТестДолжен_ПроверитьВложенностьПробрасываемыхИсключений() Экспорт

	Попытка
		ПроброситьИсключение();
	Исключение
		юТест.ПроверитьРавенство("", ИнформацияОбОшибке().Описание, "Текст исключения должен быть пустым");
	КонецПопытки;

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

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

Процедура ТестДолжен_ПроверитьРаботуФункцииТРег() Экспорт
	Текст = "шЛА Маша по шоссе(и) Сосала ""Сушку""";
	юТест.ПроверитьРавенство("Шла Маша По Шоссе(И) Сосала ""Сушку""", ТРег(Текст));
КонецПроцедуры

Процедура ТестДолжен_ПроверитьЧтоПараметрОтмеченныйЗнач_НеМеняется() Экспорт

	Парам = 1;
	НовыйПарам = ПроверкаЗнач(Парам);
	юТест.ПроверитьРавенство(1, Парам, "Ожидали, что параметр не изменит своего значения, а он поменял");

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

Функция ПроверкаЗнач(Знач Парам)
	Парам = Парам + 1;
КонецФункции

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

	Массив = Новый Массив;
	Для к=0 По 1 Цикл
		Элемент = МассивИсходный[к];
		Значение = Элемент.Значение;// ВАЖНО - именно присвоение значение приводит к багу
		Исходный = СозданиеНовойСтруктуры(Значение, Элемент.Тело);
		Массив.Добавить(Исходный);
	КонецЦикла;
	юТест.ПроверитьРавенство("слово", Массив[0].Лексема, "Ожидали, что параметр не изменит своего значения, а он поменял");

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

Функция СозданиеНовойСтруктуры(Лексема = "", Тело = "")
	Возврат Новый Структура("Лексема,Тело,Строки", Лексема, Тело, Новый Массив); // ВАЖНО - Если так, то падает
КонецФункции

Процедура ТестДолжен_ПроверитьЧтоПослеЛогическогоОператораВыполняетсяПовторОперацииСВысокимПриоритетом_Ошибка184() Экспорт

	Номер = 0;

	Массив = Новый Массив;
	Массив.Добавить("foo");
	Массив.Добавить("bar");

	ЭлементМассива = Массив[0];

	ПервыйОперанд = ВРег(ЭлементМассива) = ВРег("path83");
	ВторойОперанд = Номер+1<=Массив.Количество()-1;

	юТест.ПроверитьЛожь(ПервыйОперанд);
	юТест.ПроверитьИстину(ВторойОперанд);
	юТест.ПроверитьЛожь(ВРег(ЭлементМассива) = ВРег("path83") И Номер+1<=Массив.Количество()-1);

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

Процедура ТестДолжен_ПроверитьЧтоПослеЛогическогоОператораОбрываетсяЦепочкаПриОперацииСНизкимПриоритетом_Ошибка184() Экспорт

	Номер = 0;

	Массив = Новый Массив;
	Массив.Добавить("foo");
	Массив.Добавить("bar");

	ЭлементМассива = Массив[0];

	ПервыйОперанд = ВРег(ЭлементМассива) = ВРег("path83");
	ВторойОперанд = Номер+1<=Массив.Количество()-1;
	ТретийОперанд = ВРег(ЭлементМассива) = ВРег("path83") И Номер+1;
	юТест.ПроверитьЛожь(ПервыйОперанд);
	юТест.ПроверитьИстину(ВторойОперанд);
	юТест.ПроверитьЛожь(ТретийОперанд);

	юТест.ПроверитьИстину(ВРег(ЭлементМассива) = ВРег("path83") И Номер+1<=100 или Истина);

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

Процедура ТестДолжен_ПроверитьПриоритетОператораНЕПередОперациейСравнения() Экспорт

	Значение = 5;

	юТест.ПроверитьИстину(Значение > 2 и Не Значение+2>=10);

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

Процедура ТестДолжен_ПроверитьЧтоВозможныПараметризованныеИсключения() Экспорт
	Объект = Новый ИнформацияОбОшибке("Привет", "Параметр");

	Попытка
		ВызватьИсключение Объект;
	Исключение
		Инфо = ИнформацияОбОшибке();
		юТест.ПроверитьРавенство("Привет", Инфо.Описание);
		юТест.ПроверитьРавенство("Параметр", Инфо.Параметры);
	КонецПопытки;

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

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

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

Функция ВернутьЧтоПришло(Знач Значение) Экспорт
	Возврат Значение;
КонецФункции

Процедура ИзменитьИсходящийПараметр(Параметр) Экспорт
	Параметр = СтатусСообщения.Обычное;
КонецПроцедуры

Процедура ТестДолжен_ПроверитьПередачуПеречисленийЧерезПараметры() Экспорт

	Перем П;

	юТест.ПроверитьРавенство(СтатусСообщения.Обычное, СтатусСообщения.Обычное, "Равно само себе");
	юТест.ПроверитьРавенство(ВернутьЧтоПришло(СтатусСообщения.Обычное), СтатусСообщения.Обычное, "Не теряется при передаче/возврате");
	
	ИзменитьИсходящийПараметр(П);
	юТест.ПроверитьРавенство(П, СтатусСообщения.Обычное, "Не теряется при передаче через выходной параметр");

	юТест.ПроверитьНеРавенство(СтатусСообщения.Обычное, СтатусСообщения.Важное, "Не равно не себе");

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

Процедура ТестДолжен_ПроверитьКомпиляциюКлючевыхСловВСвойствахСтруктуры() Экспорт
	 
	 Структура = Новый Структура;
	 Структура.Вставить("Null", Null);
	 Структура.Вставить("Неопределено", Неопределено);
	 Структура.Вставить("Истина", Истина);
	 Структура.Вставить("Ложь", Ложь);
	 Структура.Вставить("И", 1);
	 Структура.Вставить("ИЛИ", 2);
	 Структура.Вставить("НЕ", 3);
	 
	 юТест.ПроверитьРавенство(Истина, Структура.Истина, "Истина");
	 юТест.ПроверитьРавенство(Ложь, Структура.Ложь, "Ложь");
	 юТест.ПроверитьРавенство(Неопределено, Структура.Неопределено, "Неопределено");
	 юТест.ПроверитьРавенство(Null, Структура.Null, "Null");
	 юТест.ПроверитьРавенство(1, Структура.И, "И");
	 юТест.ПроверитьРавенство(2, Структура.ИЛИ, "ИЛИ");
	 юТест.ПроверитьРавенство(3, Структура.НЕ, "НЕ");
	 
КонецПроцедуры

Процедура ТестДолжен_ПроверитьЧтоАргументыКоманднойСтрокиЭтоФиксированныйМассив() Экспорт

	юТест.ПроверитьРавенство(ТипЗнч(АргументыКоманднойСтроки), Тип("ФиксированныйМассив"), "Аргументы командной строки - фиксированный массив");

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

Процедура ТестДолжен_ПроверитьЗагрузкуСкриптаИзСтроки() Экспорт

	Контекст = Новый Структура("ЧислоПи", 3.1415);
	Вычислятель = ЗагрузитьСценарийИзСтроки("Перем Коэффициент Экспорт;
		|Функция Длина(Знач Радиус) Экспорт
		|	Возврат Радиус * 2 * Коэффициент;
		|КонецФункции
		|Коэффициент = ЧислоПи;", Контекст);

	юТест.ПроверитьРавенство(Вычислятель.Длина(1),    6.2830, "Вызов функции из скрипта-строки");
	юТест.ПроверитьРавенство(Вычислятель.Коэффициент, 3.1415, "Получение поля из скрипта-строки");

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

Процедура ТестДолжен_ПроверитьЗаполненностьЗначений() Экспорт

	юТест.ПроверитьИстину(ЗначениеЗаполнено(1));
	юТест.ПроверитьИстину(ЗначениеЗаполнено(Истина));
	юТест.ПроверитьИстину(ЗначениеЗаполнено(Ложь));
	юТест.ПроверитьИстину(ЗначениеЗаполнено(ТекущаяДата()));
	юТест.ПроверитьИстину(ЗначениеЗаполнено("123"));
	юТест.ПроверитьИстину(ЗначениеЗаполнено(Новый Структура("СКлючом")));
	
	юТест.ПроверитьЛожь(ЗначениеЗаполнено(Неопределено));
	юТест.ПроверитьЛожь(ЗначениеЗаполнено(Null));
	юТест.ПроверитьЛожь(ЗначениеЗаполнено(""));
	юТест.ПроверитьЛожь(ЗначениеЗаполнено(0));

	юТест.ПроверитьЛожь(ЗначениеЗаполнено('00010101'));
	юТест.ПроверитьЛожь(ЗначениеЗаполнено('000101010000'));
	юТест.ПроверитьЛожь(ЗначениеЗаполнено('00010101000000'));
	юТест.ПроверитьЛожь(ЗначениеЗаполнено('00000000'));
	юТест.ПроверитьЛожь(ЗначениеЗаполнено('000000000000'));
	юТест.ПроверитьЛожь(ЗначениеЗаполнено('00000000000000'));

	юТест.ПроверитьЛожь(ЗначениеЗаполнено(Новый Массив));
	юТест.ПроверитьЛожь(ЗначениеЗаполнено(Новый Структура));
	юТест.ПроверитьЛожь(ЗначениеЗаполнено(Новый Соответствие));
	
КонецПроцедуры

Функция ПропущенныеПараметры1(П1, П2, П3 = "1")

	Возврат Новый Структура("П1, П2, П3", П1, П2, П3);

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

Процедура ТестДолжен_ПроверитьПропускПараметров() Экспорт

	П = ПропущенныеПараметры1(,);
	юТест.ПроверитьРавенство(П.П1, Неопределено, "Пропущенный параметр без значения по-умолчанию");
	юТест.ПроверитьРавенство(П.П2, Неопределено, "Пропущенный параметр без значения по-умолчанию");
	юТест.ПроверитьРавенство(П.П3, "1", "Пропущенный параметр со значением по-умолчанию");


	П = ПропущенныеПараметры1(,,);
	юТест.ПроверитьРавенство(П.П1, Неопределено, "Пропущенный параметр без значения по-умолчанию");
	юТест.ПроверитьРавенство(П.П2, Неопределено, "Пропущенный параметр без значения по-умолчанию");
	юТест.ПроверитьРавенство(П.П3, "1", "Пропущенный параметр со значением по-умолчанию");


	П = ПропущенныеПараметры1(, 2);
	юТест.ПроверитьРавенство(П.П1, Неопределено, "Пропущенный параметр без значения по-умолчанию");
	юТест.ПроверитьРавенство(П.П2, 2, "Параметр без значения по-умолчанию");
	юТест.ПроверитьРавенство(П.П3, "1", "Пропущенный параметр со значением по-умолчанию");


	П = ПропущенныеПараметры1(3,);
	юТест.ПроверитьРавенство(П.П1, 3, "Параметр без значения по-умолчанию");
	юТест.ПроверитьРавенство(П.П2, Неопределено, "Пропущенный параметр без значения по-умолчанию");
	юТест.ПроверитьРавенство(П.П3, "1", "Пропущенный параметр со значением по-умолчанию");


	П = ПропущенныеПараметры1(3,,);
	юТест.ПроверитьРавенство(П.П1, 3, "Параметр без значения по-умолчанию");
	юТест.ПроверитьРавенство(П.П2, Неопределено, "Пропущенный параметр без значения по-умолчанию");
	юТест.ПроверитьРавенство(П.П3, "1", "Пропущенный параметр со значением по-умолчанию");


	П = ПропущенныеПараметры1(,,"4");
	юТест.ПроверитьРавенство(П.П1, Неопределено, "Пропущенный параметр без значения по-умолчанию");
	юТест.ПроверитьРавенство(П.П2, Неопределено, "Пропущенный параметр без значения по-умолчанию");
	юТест.ПроверитьРавенство(П.П3, "4", "Параметр со значением по-умолчанию");


	П = ПропущенныеПараметры1(, 2, "6");
	юТест.ПроверитьРавенство(П.П1, Неопределено, "Пропущенный параметр без значения по-умолчанию");
	юТест.ПроверитьРавенство(П.П2, 2, "Параметр без значения по-умолчанию");
	юТест.ПроверитьРавенство(П.П3, "6", "Параметр со значением по-умолчанию");

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

Процедура ТестДолжен_ПроверитьФинальнуюЗапятуюВОбъявленииМетода() Экспорт
	
	Код = "Процедура ПодключитьсяКХранилищу(Знач СтрокаСоединения, 
    |                                Знач ПользовательХранилища,
    |                                Знач ПарольХранилища = """",
    |                                Знач ИгнорироватьНаличиеПодключеннойБД = Ложь,
    |                                Знач ЗаменитьКонфигурациюБД = Истина,
    |                               	) Экспорт
	|КонецПроцедуры";
	
	Попытка
		Сценарий = ЗагрузитьСценарийИзСтроки(Код);
	Исключение
		Текст = ИнформацияОбОшибке().Описание;
		юТест.ПроверитьНеравенство(0, Найти(Текст, НСтр("ru='Ожидается идентификатор';en='Identifier expecting'")));
		Возврат;
	КонецПопытки;
	
	ВызватьИсключение "Ожидали исключение, но его не было";
	
КонецПроцедуры

Процедура ТестДолжен_ПроверитьВозможностьРазыменованияПослеТернарногоОператора() Экспорт

	Код = "x = ?(true, new array, null).count();";
	// не должно упасть
	Сценарий = ЗагрузитьСценарийИзСтроки(Код);
	
КонецПроцедуры

Процедура ТестДолжен_ПроверитьМинусВЗначенииПарамераПоУмолчанию() Экспорт

	Сценарий = ЗагрузитьСценарийИзСтроки("Функция Метод( Парам = -1 ) Экспорт Возврат Парам; КонецФункции");
	юТест.ПроверитьРавенство(Сценарий.Метод(), -1, "Параметр со значением по умолчанию -1");

	Сценарий = ЗагрузитьСценарийИзСтроки("Функция Метод( Парам = - //перевод строки" " 2 ) Экспорт Возврат Парам; КонецФункции");
	юТест.ПроверитьРавенство(Сценарий.Метод(), -2, "Параметр со значением по умолчанию -2");

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

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

	Сценарий = ЗагрузитьСценарийИзСтроки("Функция Метод( Парам = -Null ) Экспорт Возврат Парам; КонецФункции");
	юТест.ПроверитьРавенство(Сценарий.Метод(), Null, "Параметр со значением по умолчанию Null");

	Ошибка = НСтр("ru='Ожидается числовая константа';en='Numeric constant expected'");
	юТест.ПроверитьКодСОшибкой("Процедура Метод( Парам = - ""1"" ) КонецПроцедуры", Ошибка );
	юТест.ПроверитьКодСОшибкой("Процедура Метод( Парам = -'00010101') КонецПроцедуры", Ошибка );

	Ошибка = НСтр("ru='Ожидается константа';en='Constant expected'");
	юТест.ПроверитьКодСОшибкой("Процедура Метод( Парам = - п ) КонецПроцедуры", Ошибка );
	юТест.ПроверитьКодСОшибкой("Процедура Метод( Парам = - -1 ) КонецПроцедуры", Ошибка );
	юТест.ПроверитьКодСОшибкой("Процедура Метод( Парам = --1 ) КонецПроцедуры", Ошибка );

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

Процедура ТестДолжен_ПроверитьПрерываниеВложенныхПопыток() Экспорт
	Счетчик = 0;
	Для й=1 по 3 Цикл
		Попытка
			Попытка
				Попытка
					Прервать
				Исключение
					Счетчик = Счетчик + 1;
				КонецПопытки
			Исключение
				Счетчик = Счетчик + 1;
			КонецПопытки
		Исключение
			Счетчик = Счетчик + 1;
		КонецПопытки
	Конеццикла;
	
	Попытка
		ВызватьИсключение "НовоеНеВложенное";
		Возврат;
	Исключение
		юТест.ПроверитьРавенство(0, Счетчик);
		Возврат;
	КонецПопытки;

	ВызватьИсключение "Не должны дойти до этой строки";
	
КонецПроцедуры

Процедура ТестДолжен_ПроверитьПродолжениеВложенныхПопыток() Экспорт
	Счетчик = 0;
	Попытка
		Для й=1 по 3 Цикл
			Счетчик = Счетчик + 1;
			Попытка
				Попытка
					Продолжить
				Исключение
					Счетчик = Счетчик + 1;
				КонецПопытки
			Исключение
				Счетчик = Счетчик + 1;
			КонецПопытки;
		Конеццикла;
	Исключение
		Счетчик = Счетчик + 1;
	КонецПопытки;
	
	юТест.ПроверитьРавенство(3, Счетчик);
	
КонецПроцедуры

Процедура ТестДолжен_ПроверитьИнформацияОбОшибкеВнеИсключения() Экспорт
	
	ИнформацияОбОшибке = ИнформацияОбОшибке();

	юТест.ПроверитьРавенство("", ИнформацияОбОшибке.ИмяМодуля);
	юТест.ПроверитьРавенство("", ИнформацияОбОшибке.ИсходнаяСтрока);
	юТест.ПроверитьРавенство(0, ИнформацияОбОшибке.НомерСтроки);
	юТест.ПроверитьРавенство("", ИнформацияОбОшибке.Описание);
	юТест.ПроверитьРавенство("", ИнформацияОбОшибке.ПодробноеОписаниеОшибки());
	юТест.ПроверитьРавенство(Неопределено, ИнформацияОбОшибке.Параметры);

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

Процедура ТестДолжен_ПроверитьПередачуПараметровПоСсылке()  Экспорт

	Структура = Новый Структура("Поле",  1);

	Т = 0;
	Рез = Структура.Свойство("Поле", Т);
	юТест.ПроверитьРавенство(1, Т, "Для переменной");

	Массив = Новый Массив(1);
	Рез = Структура.Свойство("Поле", Массив[0]);
	юТест.ПроверитьРавенство(1, Массив[0], "Для элемента массива");

	Структура2 = Новый Структура("Поле",  2);
	Рез = Структура.Свойство("Поле", Структура2.Поле);
	юТест.ПроверитьРавенство(1, Структура2.Поле, "Для поля структуры");
	
	Рез = Структура.Свойство("Поле", 3); // не должно упасть
	юТест.ПроверитьРавенство(истина, Рез);

	Рез = Структура.Свойство("Поле", ТекущаяДата()); // не должно упасть
	юТест.ПроверитьРавенство(истина, Рез);

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

Процедура ТестДолжен_ПроверитьСравнениеНаБольшеМеньше() Экспорт
	 
	Ошибка = "Сравнение на больше/меньше для данного типа не поддерживается";

	юТест.ПроверитьКодСОшибкой(
		"Рез = (СтатусСообщения.БезСтатуса <= СтатусСообщения.БезСтатуса);", 
		Ошибка, "Для одинаковых значений перечислений" );
		
	юТест.ПроверитьКодСОшибкой(
		"Рез = (ЦветКонсоли.Черный < СтатусСообщения.БезСтатуса);",
		Ошибка, "Для значений перечислений разных типов" );

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

	юТест.ПроверитьКодСОшибкой(
		"Рез = (ТипЗнч(истина) > ТипЗнч(0));",
		Ошибка, "Для значений типа 'Тип'" );

	юТест.ПроверитьКодСОшибкой(
		"Массив = Новый Массив(1);
		|Структура = Новый Структура;
		|Рез = (Массив > Структура);",
		Ошибка, "Для объектов разных типов" );
		
	юТест.ПроверитьКодСОшибкой(
		"Массив = Новый Массив(1);
		|Массив2 = Новый Массив(1);;
		|Рез = (Массив <= Массив2);",
		Ошибка, "Для одинаковых объектов" );
	
КонецПроцедуры

Процедура ТестДолжен_ПроверитьЧто_ЭтотОбъект_НедоступенДляЗаписи() Экспорт
    юТест.ПроверитьКодСОшибкой("ЭтотОбъект = 8", "Свойство 'ЭтотОбъект' недоступно для записи");
КонецПроцедуры

Процедура ТестДолжен_ПроверитьОперацииСДатой_Сложение() Экспорт

	ТекущееВремя = ТекущаяДата();
	Попытка
		ЧерезЧас = ТекущееВремя + "3600";
		юТест.ПроверитьРавенство(ЧерезЧас,ТекущееВремя+3600);
	Исключение
		ВызватьИсключение("Не работает сложение даты со строкой");
	КонецПопытки;

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

Процедура ТестДолжен_ПроверитьОперацииСДатой_Вычитание() Экспорт

	ТекущееВремя = ТекущаяДата();
	Попытка
		ЧасомРанее = ТекущееВремя - "3600";
		юТест.ПроверитьРавенство(ЧасомРанее,ТекущееВремя-3600);
	Исключение
		ВызватьИсключение("Не работает вычитание даты и строки");
	КонецПопытки;

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

Процедура ТестДолжен_ПроверитьОперацииСДатой_СложениеДат() Экспорт

	ТекущееВремя = ТекущаяДата();

	Попытка
		ТекущееВремя = ТекущееВремя +  '00010101';
	Исключение
		Возврат;
	КонецПопытки;

	ВызватьИсключение "Не должно работать сложение дат";
КонецПроцедуры

Процедура ТестДолжен_ПроверитьВложенныеИсключения() Экспорт
	ИсключениеВоВложеннойПопытке();
КонецПроцедуры

Процедура ТестДолжен_ПроверитьВложенныеИсключенияДелегат() Экспорт
	Действие = Новый Действие(ЭтотОбъект, "ИсключениеВоВложеннойПопытке");
	Действие.Выполнить();
	КонецПроцедуры

Процедура ТестДолжен_ПроверитьВложенныеИсключенияФоновоеЗадание() Экспорт

	ФоновоеЗадание = ФоновыеЗадания.Выполнить(ЭтотОбъект, "ИсключениеВоВложеннойПопытке");
	ФоновоеЗадание.ОжидатьЗавершения();

	Если ФоновоеЗадание.ИнформацияОбОшибке <> Неопределено Тогда

		ВызватьИсключение СтрШаблон(
			"%1 (%2:%3)",
			ФоновоеЗадание.ИнформацияОбОшибке.Описание,
			ФоновоеЗадание.ИнформацияОбОшибке.ИмяМодуля,
			ФоновоеЗадание.ИнформацияОбОшибке.НомерСтроки
		);

	КонецЕсли;

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

Процедура ИсключениеВоВложеннойПопытке() Экспорт

	Попытка

		Попытка
			ВызватьИсключение "Исключение из вложенной попытки должна перехватываться";
		Исключение
		КонецПопытки;

		ВызватьИсключение "Исключение из внешней попытки должна перехватываться";

	Исключение
		// Успех
	КонецПопытки;

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