tests/valuetable.os - develop - EvilBeaver/OneScript

tests/valuetable.os
1 468 строк76 KB
EvilBeaver
Попытка исправить неиндексированный поиск в ТЗ методом Найти
12 апр 2026, 12:53
12 апр 2026, 12:53144fc70
///////////////////////////////////////////////////////////////////////
//
// Тест проверки работы таблицы значений
//
//
///////////////////////////////////////////////////////////////////////

Перем юТест;

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

Функция Версия() Экспорт
	Возврат "0.2";
КонецФункции

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

	юТест = ЮнитТестирование;
	ВсеТесты = Новый Массив;

	ВсеТесты.Добавить("ТестДолжен_СоздатьТаблицуЗначений");
	ВсеТесты.Добавить("ТестДолжен_СоздатьУдалитьКолонки");
	ВсеТесты.Добавить("ТестДолжен_СоздатьУдалитьСтроки");
	ВсеТесты.Добавить("ТестДолжен_ПереместитьСтроки");
	ВсеТесты.Добавить("ТестДолжен_ОтработатьСДанными");

	ВсеТесты.Добавить("ТестДолжен_ВыгрузитьКолонкуВМассив");
	ВсеТесты.Добавить("ТестДолжен_НайтиСтрокуВТаблице");
	ВсеТесты.Добавить("ТестДолжен_НайтиНесколькоСтрокВТаблице");
	ВсеТесты.Добавить("ТестДолжен_СкопироватьТаблицуПолностью");
	ВсеТесты.Добавить("ТестДолжен_СкопироватьТаблицуПоМассивуСтрок");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьИсключениеПриКопированииТаблицыПоМассивуСтрок");
	ВсеТесты.Добавить("ТестДолжен_СкопироватьТаблицуНесколькоКолонок");
	ВсеТесты.Добавить("ТестДолжен_СкопироватьТаблицуПоОтбору");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьСверткуБезУказанияКолонок");

	ВсеТесты.Добавить("ТестДолжен_ЗагрузитьКолонку");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьТипизациюКолонки");

	ВсеТесты.Добавить("ТестДолжен_ПроверитьСверткуБольшойТаблицы");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьСверткуБольшойТаблицы2");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьСверткуПоДвумКолонкам");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьСверткуПоДвумКолонкамСРазнымиТипами");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьСверткуПоКолонкамСуммированияСРазнымиТипами");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьСверткуПоОднойКолонкеСРазнымиТипами");

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

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

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

	Перем Т;

	Т = Новый ТаблицаЗначений;
	КоличествоДобавляемыхКолонокСтрок = 5;

	Для Инд = 1 По КоличествоДобавляемыхКолонокСтрок Цикл

		Т.Колонки.Добавить("К" + Инд);
		Т.Добавить();

	КонецЦикла;

	юТест.ПроверитьРавенство(Т.Колонки.Количество(), КоличествоДобавляемыхКолонокСтрок);
	юТест.ПроверитьРавенство(Т.Количество(), КоличествоДобавляемыхКолонокСтрок);

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

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

	Перем Т;

	Т = Новый ТаблицаЗначений;

	К1 = Т.Колонки.Добавить("К1");
	К2 = Т.Колонки.Добавить("К2");
	К3 = Т.Колонки.Добавить("К3");
	К4 = Т.Колонки.Добавить("К4");
	К5 = Т.Колонки.Добавить("К5");

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

	// Удаление колонки по ссылке
	Т.Колонки.Удалить(К3);

	юТест.ПроверитьРавенство(Т.Колонки.Количество(), 4);
	юТест.ПроверитьРавенство(Т.Колонки.Найти("К3"), Неопределено);
	юТест.ПроверитьРавенство(Т.Колонки.Найти("К2"), К2);

	Строка1 = Т.Добавить();
	Строка2 = Т.Добавить();

	К6 = Т.Колонки.Добавить("К6");

	// Доступность К6 после добавления строк

	Попытка

		Строка1["К6"] = 123;
		юТест.ПроверитьРавенство(Строка1["К6"], 123);

	Исключение

		юТест.ПроверитьИстину(Ложь, "Колонка К6 не доступна!");

	КонецПопытки;

	// Удаление колонки по индексу
	Т.Колонки.Удалить(0);

	юТест.ПроверитьРавенство(Т.Колонки.Количество(), 4);
	юТест.ПроверитьРавенство(Т.Колонки.Найти("К1"), Неопределено);
	юТест.ПроверитьРавенство(Т.Колонки.Найти("К2"), К2);

	// Удаление колонки по имени
	Т.Колонки.Удалить("К4");

	юТест.ПроверитьРавенство(Т.Колонки.Количество(), 3);
	юТест.ПроверитьРавенство(Т.Колонки.Найти("К4"), Неопределено);
	юТест.ПроверитьРавенство(Т.Колонки.Найти("К2"), К2);

	// Недоступность удалённой колонки

	Попытка

		Значение = Строка1["К1"];
		юТест.ПроверитьИстину(Ложь, "Доступна удалённая колонка!");

	Исключение

	КонецПопытки;

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

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

	Перем Т;

	Т = Новый ТаблицаЗначений;

	К1 = Т.Колонки.Добавить("К1");
	К2 = Т.Колонки.Добавить("К2");
	К3 = Т.Колонки.Добавить("К3");
	К4 = Т.Колонки.Добавить("К4");
	К5 = Т.Колонки.Добавить("К5");

	С1 = Т.Добавить();
	С2 = Т.Добавить();
	С2_5 = Т.Добавить();
	С2_6 = Т.Добавить();
	С3 = Т.Добавить();
	С4 = Т.Добавить();

	Т.Удалить(С2_5);
	Т.Удалить(2);

	юТест.ПроверитьРавенство(Т.Количество(), 4);

	юТест.ПроверитьРавенство(Т.Получить(0), С1);
	юТест.ПроверитьРавенство(Т.Получить(1), С2);
	юТест.ПроверитьРавенство(Т.Получить(2), С3);
	юТест.ПроверитьРавенство(Т.Получить(3), С4);

	юТест.ПроверитьРавенство(Т[0], С1);
	юТест.ПроверитьРавенство(Т[1], С2);
	юТест.ПроверитьРавенство(Т[2], С3);
	юТест.ПроверитьРавенство(Т[3], С4);

	юТест.ПроверитьРавенство(Т.Индекс(С1), 0);
	юТест.ПроверитьРавенство(Т.Индекс(С2), 1);
	юТест.ПроверитьРавенство(Т.Индекс(С3), 2);
	юТест.ПроверитьРавенство(Т.Индекс(С4), 3);

	Обошли = Новый Соответствие;
	Для Каждого мСтрокаТаблицы Из Т Цикл

		Обошли.Вставить(мСтрокаТаблицы, Истина);

	КонецЦикла;

	юТест.ПроверитьИстину(Обошли.Получить(С1), "Обход бегунком");
	юТест.ПроверитьИстину(Обошли.Получить(С2), "Обход бегунком");
	юТест.ПроверитьИстину(Обошли.Получить(С3), "Обход бегунком");
	юТест.ПроверитьИстину(Обошли.Получить(С4), "Обход бегунком");

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

Функция ПроверитьПорядок(Т, П1, П2, П3, П4, П5)

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

	Для Инд = 0 По 4 Цикл

		Если Т[Инд].Индекс <> Массив[Инд] Тогда
			Возврат Ложь;
		КонецЕсли;

	КонецЦикла;

	Возврат Истина;

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

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

	Перем Т;

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

	Для Инд = 1 По 5 Цикл
		Т.Добавить().Индекс = Инд;
	КонецЦикла;

	С1 = Т[0];
	С2 = Т[1];
	С3 = Т[2];
	С4 = Т[3];
	С5 = Т[4];

	// Проверим обычное перемещение

	Т.Сдвинуть(С2, -1);
	ПроверитьПорядок(Т, 2, 1, 3, 4, 5);

	Т.Сдвинуть(С1, 2);
	ПроверитьПорядок(Т, 2, 3, 4, 1, 5);

	Т.Сдвинуть(3, -2);
	ПроверитьПорядок(Т, 2, 1, 3, 4, 5);

	Т.Сдвинуть(1, 2);
	ПроверитьПорядок(Т, 2, 3, 4, 1, 5);

	// Проверим приведение типа
	Т.Сдвинуть("2", 2);
	ПроверитьПорядок(Т, 2, 3, 1, 5, 4);

	Т.Сдвинуть("1", "2");
	ПроверитьПорядок(Т, 2, 1, 5, 3, 4);

	// Проверим крайние случаи
	Т.Сдвинуть(0, 4);
	ПроверитьПорядок(Т, 1, 5, 3, 4, 2);

	Т.Сдвинуть(4, -4);
	ПроверитьПорядок(Т, 2, 1, 5, 3, 4);

	// Проверим ошибки
	Ошибка = "Сдвиг за пределы вниз";
	Попытка
		Т.Сдвинуть(0, 5);
	Исключение
		Ошибка = ИнформацияОбОшибке().Описание;
	КонецПопытки;
	юТест.ПроверитьРавенство(Ошибка, "Неправильное смещение внутри коллекции");

	Ошибка = "Сдвиг за пределы вверх";
	Попытка
		Т.Сдвинуть(1, -3);
	Исключение
		Ошибка = ИнформацияОбОшибке().Описание;
	КонецПопытки;
	юТест.ПроверитьРавенство(Ошибка, "Неправильное смещение внутри коллекции");

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

	Ошибка = "Сдвиг несуществующего элемента";
	ДругаяТЗ = Новый ТаблицаЗначений;
	ДругаяТЗ.Колонки.Добавить("Индекс");
	ДругаяТЗ.Добавить().Индекс = 1;
	Попытка
		Т.Сдвинуть(ДругаяТЗ[0], 2);
	Исключение
		Ошибка = ИнформацияОбОшибке().Описание;
	КонецПопытки;
	юТест.ПроверитьРавенство(Ошибка, "Строка не принадлежит таблице значений");

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

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

	Перем Т;

	Т = Новый ТаблицаЗначений;

	Т.Колонки.Добавить("Количество");
	Т.Колонки.Добавить("Цена");
	Т.Колонки.Добавить("Сумма");

	Для Инд = 1 По 5 Цикл

		НоваяСтрока = Т.Добавить();
		НоваяСтрока.Количество = Инд;

	КонецЦикла;

	Цены = Новый Массив;
	Цены.Добавить(100);
	Цены.Добавить(50);
	Цены.Добавить(30);
	Цены.Добавить(32.3);
	Цены.Добавить(16);

	Т.ЗагрузитьКолонку(Цены, "Цена");

	мСумма = 0;
	Для Каждого мСтрока Из Т Цикл

		мСтрока.Сумма = мСтрока.Количество * мСтрока.Цена;
		мСумма = мСумма + мСтрока.Сумма;

	КонецЦикла;

	КолонкаСумма = Т.Колонки.Сумма;

	юТест.ПроверитьРавенство(Т.Итог("Сумма"), мСумма);
	юТест.ПроверитьРавенство(Т.Итог(2), мСумма);
	юТест.ПроверитьРавенство(Т.Итог(КолонкаСумма), мСумма);


	Т.Свернуть("", "Сумма");

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

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

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

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

	ЭталонКлючей = Новый Массив;
	ЭталонЗначений = Новый Массив;

	Для Сч = 1 По 5 Цикл
		С = Т.Добавить();
		С.Ключ = "Ключ" + Строка(Сч);
		С.Значение = Сч;

		ЭталонКлючей.Добавить(С.Ключ);
		ЭталонЗначений.Добавить(С.Значение);

	КонецЦикла;

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

	// Передаем индекс колонки
	юТест.ПроверитьИстину(МассивыИдентичны(Т.ВыгрузитьКолонку(0), ЭталонКлючей), "Массивы ключей должны совпадать");
	юТест.ПроверитьИстину(МассивыИдентичны(Т.ВыгрузитьКолонку(1), ЭталонЗначений), "Массивы значений должны совпадать");

	// Передаем колонку
	юТест.ПроверитьИстину(МассивыИдентичны(Т.ВыгрузитьКолонку(Т.Колонки.Ключ), ЭталонКлючей), "Массивы ключей должны совпадать");
	юТест.ПроверитьИстину(МассивыИдентичны(Т.ВыгрузитьКолонку(Т.Колонки.Значение), ЭталонЗначений), "Массивы значений должны совпадать");

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

Функция МассивыИдентичны(Знач Проверяемый, Знач Эталон)
	Если Проверяемый.Количество() <> Эталон.Количество() Тогда
		Возврат Ложь;
	КонецЕсли;

	Для Сч = 0 По Проверяемый.Количество()-1 Цикл
		Если Проверяемый[Сч] <> Эталон[Сч] Тогда
			Возврат Ложь;
		КонецЕсли;
	КонецЦикла;

	Возврат Истина;

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

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

	Для Сч = 1 По 5 Цикл
		С = Т.Добавить();
		С.Ключ = "Ключ" + Строка(Сч);
		С.Значение = Сч;
	КонецЦикла;

	ИскомаяСтрока = Т.Найти("Ключ2", "Ключ");
	юТест.ПроверитьЛожь(ИскомаяСтрока = Неопределено, "Строка должна быть найдена");
	юТест.ПроверитьРавенство(ИскомаяСтрока.Значение, 2);

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

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

	Для Сч = 1 По 8 Цикл
		С = Т.Добавить();

		Если Сч % 2 Тогда
			С.Ключ = "Истина";
			С.Значение = Истина;
		Иначе
			С.Ключ = "Ложь";
			С.Значение = Ложь;
		КонецЕсли;

	КонецЦикла;

	КлючиПоиска = Новый Структура("Ключ,Значение", "Истина", Истина);
	НайденныеСтроки = Т.НайтиСтроки(КлючиПоиска);

	юТест.ПроверитьРавенство(НайденныеСтроки.Количество(), 4, "Количество строк должно совпадать с эталоном");

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

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

Функция СоздатьТаблицуСДанными()

	Т = Новый ТаблицаЗначений;
	Т.Колонки.Добавить("Ключ");
	Т.Колонки.Добавить("Значение");
	Т.Колонки.Добавить("К3");

	Для Сч = 1 По 5 Цикл
		С = Т.Добавить();
		С.Ключ = "Ключ" + Строка(Сч);
		С.Значение = Сч;
		С.К3 = "К3-" + Сч
	КонецЦикла;

	Возврат Т;

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

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

	Т = СоздатьТаблицуСДанными();
	Т2 = Т.Скопировать();

	юТест.ПроверитьНеравенство(Т, Т2);
	юТест.ПроверитьРавенство(Т.Количество(), Т2.Количество());
	Для Сч = 0 По Т.Количество() - 1 Цикл
		С1 = Т[сч];
		С2 = Т2[сч];
		юТест.ПроверитьРавенство(С1.Ключ, С2.Ключ, "Равенство Ключей в строке " + Сч);
		юТест.ПроверитьРавенство(С1.Значение, С2.Значение, "Равенство Значений в строке " + Сч);
		юТест.ПроверитьРавенство(С1.К3, С2.К3, "Равенство КЗ в строке " + Сч);
		юТест.ПроверитьНеравенство(С1, С2);
	КонецЦикла;

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

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

	Т = СоздатьТаблицуСДанными();

	МассивСтрок = Новый Массив;
	МассивСтрок.Добавить(Т[0]);
	МассивСтрок.Добавить(Т[2]);
	Т2 = Т.Скопировать(МассивСтрок);

	юТест.ПроверитьНеравенство(Т, Т2);
	юТест.ПроверитьРавенство(2, Т2.Количество());
	Для Сч = 0 По Т2.Количество() - 1 Цикл
		С1 = МассивСтрок[сч];
		С2 = Т2[сч];
		юТест.ПроверитьРавенство(С1.Ключ, С2.Ключ, "Равенство Ключей в строке " + Сч);
		юТест.ПроверитьРавенство(С1.Значение, С2.Значение, "Равенство Значений в строке " + Сч);
		юТест.ПроверитьРавенство(С1.К3, С2.К3, "Равенство КЗ в строке " + Сч);
		юТест.ПроверитьНеравенство(С1, С2);
	КонецЦикла;

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

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

	Т = СоздатьТаблицуСДанными();

	МассивСтрок = Новый Массив;
	МассивСтрок.Добавить(Т[0]);
	МассивСтрок.Добавить(Т[2]);
	Т2 = Т.Скопировать(МассивСтрок, "Ключ, Значение");

	юТест.ПроверитьНеравенство(Т, Т2);
	юТест.ПроверитьРавенство(2, Т2.Количество());
	юТест.ПроверитьРавенство(2, Т2.Колонки.Количество());
	Для Сч = 0 По Т2.Количество() - 1 Цикл
		С1 = МассивСтрок[сч];
		С2 = Т2[сч];
		юТест.ПроверитьРавенство(С1.Ключ, С2.Ключ, "Равенство Ключей в строке " + Сч);
		юТест.ПроверитьРавенство(С1.Значение, С2.Значение, "Равенство Значений в строке " + Сч);
		юТест.ПроверитьНеравенство(С1, С2);
	КонецЦикла;

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

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

	Т = СоздатьТаблицуСДанными();
	Т.Добавить().Значение = 4;

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

	юТест.ПроверитьНеравенство(Т, Т2);
	юТест.ПроверитьРавенство(2, Т2.Количество());
	юТест.ПроверитьРавенство(1, Т2.Колонки.Количество());
	юТест.ПроверитьРавенство("Ключ4", Т2[0].Ключ);
	юТест.ПроверитьРавенство(Неопределено, Т2[1].Ключ);

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

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

	Т = СоздатьТаблицуСДанными();

	Т0 = Новый ТаблицаЗначений();
	Т0.Колонки.Добавить("Тест");
	Т0.Добавить().Тест = 1;

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

	Попытка
		Т2 = Т.Скопировать(МассивСтрок);
	Исключение
		Возврат;
	КонецПопытки;
	
	ВызватьИсключение "Ожидали исключение, но его не было";

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


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

	Перем Т;

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

	Т.Добавить().Колонка1 = "Значение1";
	Т.Добавить().Колонка1 = "Значение2";

	Т.Добавить().Колонка1 = "Значение1";
	Т.Добавить().Колонка1 = "Значение2";

	// Вызываем свёртку БЕЗ указания второго параметра
	Т.Свернуть("Колонка1");

	Т.Сортировать("Колонка1");

	юТест.ПроверитьРавенство(Т.Количество(), 2, "После свёртки должно остаться 2 строки");
	юТест.ПроверитьРавенство(Т.Получить(0).Колонка1, "Значение1", "Свёртка по значениям");
	юТест.ПроверитьРавенство(Т.Получить(1).Колонка1, "Значение2", "Свёртка по значениям");

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

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

	Т = Новый ТаблицаЗначений;

	Т.Колонки.Добавить("Количество1");
	Т.Колонки.Добавить("Количество2");
	Т.Колонки.Добавить("Количество3");

	Для Инд = 1 По 5 Цикл

		НоваяСтрока = Т.Добавить();

	КонецЦикла;

	Количество = Новый Массив;
	Количество.Добавить(1);
	Количество.Добавить(2);
	Количество.Добавить(3);
	Количество.Добавить(4);
	Количество.Добавить(5);

	Т.ЗагрузитьКолонку(Количество, "Количество1");
	Т.ЗагрузитьКолонку(Количество, 1);
	Т.ЗагрузитьКолонку(Количество, Т.Колонки.Количество3);

	юТест.ПроверитьРавенство(Т.Итог("Количество1"), 15);
	юТест.ПроверитьРавенство(Т.Итог("Количество2"), 15);
	юТест.ПроверитьРавенство(Т.Итог("Количество3"), 15);

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

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

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

	СтрокаТаблицы = Таблица.Добавить();
	СтрокаТаблицы.Колонка1 = 1;

	юТест.ПроверитьРавенство(СтрокаТаблицы.Колонка1, "1");

	СтрокаТаблицы.Колонка1 = Неопределено;
	юТест.ПроверитьРавенство(СтрокаТаблицы.Колонка1, "", "Неопределено - Пустая строка");

	Таблица.Колонки.Добавить("Колонка2", Новый ОписаниеТипов("Строка,Число"));
	СтрокаТаблицы.Колонка2 = 1;
	юТест.ПроверитьРавенство(СтрокаТаблицы.Колонка2, 1);

	СтрокаТаблицы.Колонка2 = "ъ";
	юТест.ПроверитьРавенство(СтрокаТаблицы.Колонка2, "ъ");

	СтрокаТаблицы.Колонка2 = Неопределено;
	юТест.ПроверитьРавенство(СтрокаТаблицы.Колонка2, Неопределено);

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

// -- issue #1010

Функция ТестовыеДанные()
	Возврат  "135,29,91,60,30,120,61,31,92,121,130,131,133,8,9,10,11,134,13,14,15,16,5," +
	"62,32,132,7,8,63,10,11,64,33,93,122,5,6,7,8,12,65,34,94,123,5,6,7,8,13,66,35,95,4,5," +
	"6,7,8,14,96,67,36,4,5,15,68,37,97,4,5,6,9,17,124,69,38,98,4,5,6,19,70,39,99,4,5,6,7," +
	"20,71,40,100,4,5,6,21,72,41,22,23,73,42,24,74,43,101,25,75,102,44,4,5,6,26,114,128," +
	"-1,45,103,76,46,4,77,47,104,4,5,6,7,8,9,10,11,12,13,14,15,16,5,78,48,6,7,8,79,10,11," +
	"80,49,105,4,5,6,7,8,12,81,50,106,4,5,6,7,8,13,82,51,107,4,5,6,7,8,14,108,83,52,4,5," +
	"15,84,53,109,4,5,6,9,17,125,85,54,110,4,5,6,19,86,55,111,4,5,6,7,20,87,56,112,4,5,6," +
	"21,88,57,22,23,89,58,24,90,59,113,25,1,3,2,4,5,6,26,115,129";
КонецФункции

Функция ТестоваяТаблица()
	ТЗ = Новый ТаблицаЗначений;
	ТЗ.Колонки.Добавить("Значение1");
	ТЗ.Колонки.Добавить("Значение2");
	ТЗ.Колонки.Добавить("Количество1");
	ТЗ.Колонки.Добавить("Количество2");
	Возврат ТЗ;
КонецФункции

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

	Строка = ТестовыеДанные();
	ТЗ = ТестоваяТаблица();

	Для каждого Элемент Из СтрРазделить(Строка, ",") Цикл
		СтрТЗ = ТЗ.Добавить();
		СтрТЗ.Значение1 = СокрЛП(Элемент);
		СтрТЗ.Количество1 = 1;
	КонецЦикла;

	ТЗ.Свернуть("Значение1", "Количество1");

	юТест.ПроверитьРавенство(ТЗ.Количество(), 127, "Количество строк после свёртки");
	юТест.ПроверитьРавенство(ТЗ.Колонки.Количество(), 2, "Количество колонок после свёртки");

	ПроверитьВТаблицеКоличествоДляЗначения1(ТЗ, "53", 1);
	ПроверитьВТаблицеКоличествоДляЗначения1(ТЗ, "12", 3);
	ПроверитьВТаблицеКоличествоДляЗначения1(ТЗ, "4", 18);
	ПроверитьВТаблицеКоличествоДляЗначения1(ТЗ, "8", 10);
	ПроверитьВТаблицеКоличествоДляЗначения1(ТЗ, "6", 18);
КонецПроцедуры

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

	Строка = ТестовыеДанные();
	ТЗ = ТестоваяТаблица();

	Для каждого Элемент Из СтрРазделить(Строка, ",") Цикл
		СтрТЗ = ТЗ.Добавить();
		СтрТЗ.Значение1 = СокрЛП(Элемент);
		СтрТЗ.Значение2 = СокрЛП(Элемент);
		СтрТЗ.Количество1 = 1;
	КонецЦикла;
	ТЗ2 = ТЗ.Скопировать(, "Значение1, Количество1");

	ТЗ2.Свернуть("Значение1", "Количество1");
	ТЗ.Свернуть("Значение1, Значение2", "Количество1");

	юТест.ПроверитьРавенство(ТЗ.Количество(), 127, "Количество строк после свёртки");
	юТест.ПроверитьРавенство(ТЗ.Колонки.Количество(), 3, "Количество колонок после свёртки");

	Для Каждого Стр Из ТЗ Цикл
		ПроверитьВТаблицеКоличествоДляЗначения1(ТЗ2, Стр.Значение1, Стр.Количество1)
	КонецЦикла;
КонецПроцедуры

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

	Строка = ТестовыеДанные();
	ТЗ = ТестоваяТаблица();

	Сч=0;
	Для каждого Элемент Из СтрРазделить(Строка, ",") Цикл
		СтрТЗ = ТЗ.Добавить();
		СтрТЗ.Значение1 = СокрЛП(Элемент);
		СтрТЗ.Значение2 = Сч;
		СтрТЗ.Количество1 = 1;
		Сч=(Сч+1)%3;
	КонецЦикла;

	ТЗ.Свернуть("Значение1,Значение2", "Количество1");

	юТест.ПроверитьРавенство(ТЗ.Количество(), 159, "Количество строк после свёртки");
	юТест.ПроверитьРавенство(ТЗ.Колонки.Количество(), 3, "Количество колонок после свёртки");

	ПроверитьВТаблицеКоличествоДляЗначения1(ТЗ, "12", 2);
	ПроверитьВТаблицеКоличествоДляЗначения1(ТЗ, "4", 7);
	ПроверитьВТаблицеКоличествоДляЗначения1(ТЗ, "8", 2);
	ПроверитьВТаблицеКоличествоДляЗначения1(ТЗ, "6", 8);
КонецПроцедуры

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

	Строка = ТестовыеДанные();
	ТЗ = ТестоваяТаблица();

	Сч=0;
	Для каждого Элемент Из СтрРазделить(Строка, ",") Цикл
		СтрТЗ = ТЗ.Добавить();
		СтрТЗ.Значение1 = СокрЛП(Элемент);
		СтрТЗ.Значение2 = ?(Сч=0,Элемент,'20200511');
		СтрТЗ.Количество1 = 1;
		Сч=(Сч+1)%2;
	КонецЦикла;

	ТЗ.Свернуть("Значение1,Значение2", "Количество1");

	юТест.ПроверитьРавенство(ТЗ.Количество(), 149, "Количество строк после свёртки");
	юТест.ПроверитьРавенство(ТЗ.Колонки.Количество(), 3, "Количество колонок после свёртки");

	ПроверитьВТаблицеКоличествоДляЗначения1(ТЗ, "12", 1);
	ПроверитьВТаблицеКоличествоДляЗначения1(ТЗ, "4", 10);
	ПроверитьВТаблицеКоличествоДляЗначения1(ТЗ, "8", 5);
	ПроверитьВТаблицеКоличествоДляЗначения1(ТЗ, "6", 10);
КонецПроцедуры

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

	Строка = ТестовыеДанные();
	ТЗ = ТестоваяТаблица();

	Сч=0;
	Для каждого Элемент Из СтрРазделить(Строка, ",") Цикл
		СтрТЗ = ТЗ.Добавить();
		СтрТЗ.Значение1 = СокрЛП(Элемент);
		СтрТЗ.Количество1 = 1;
		СтрТЗ.Количество2 = ?(Сч=0,1,'20200511');
		Сч=(Сч+1)%2;
	КонецЦикла;

	ТЗ.Свернуть("Значение1", "Количество1,Количество2");

	юТест.ПроверитьРавенство(ТЗ.Количество(), 127, "Количество строк после свёртки");
	юТест.ПроверитьРавенство(ТЗ.Колонки.Количество(), 3, "Количество колонок после свёртки");

	ПроверитьВТаблицеКоличествоДляЗначения1(ТЗ, "12", 3, "Количество1");
	ПроверитьВТаблицеКоличествоДляЗначения1(ТЗ, "12", 2, "Количество2");
	ПроверитьВТаблицеКоличествоДляЗначения1(ТЗ, "4", 18, "Количество1");
	ПроверитьВТаблицеКоличествоДляЗначения1(ТЗ, "4", 10, "Количество2");
	ПроверитьВТаблицеКоличествоДляЗначения1(ТЗ, "8", 10, "Количество1");
	ПроверитьВТаблицеКоличествоДляЗначения1(ТЗ, "8", 5, "Количество2");
	ПроверитьВТаблицеКоличествоДляЗначения1(ТЗ, "6", 18, "Количество1");
	ПроверитьВТаблицеКоличествоДляЗначения1(ТЗ, "6", 10, "Количество2");
КонецПроцедуры

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

	Строка = ТестовыеДанные();
	ТЗ = ТестоваяТаблица();

	Сч=0;
	Для каждого Элемент Из СтрРазделить(Строка, ",") Цикл
		СтрТЗ = ТЗ.Добавить();
		СтрТЗ.Значение1 = ?(Сч=0,Число(Элемент),СокрЛП(Элемент));
		СтрТЗ.Количество1 = 1;
		Сч=(Сч+1)%2;
	КонецЦикла;

	ТЗ.Свернуть("Значение1", "Количество1");

	юТест.ПроверитьРавенство(ТЗ.Количество(), 149, "Количество строк после свёртки");
	юТест.ПроверитьРавенство(ТЗ.Колонки.Количество(), 2, "Количество колонок после свёртки");

	ПроверитьВТаблицеКоличествоДляЗначения1(ТЗ, "12", 1);
	ПроверитьВТаблицеКоличествоДляЗначения1(ТЗ, 12, 2);
	ПроверитьВТаблицеКоличествоДляЗначения1(ТЗ, "4", 8);
	ПроверитьВТаблицеКоличествоДляЗначения1(ТЗ, 4, 10);
	ПроверитьВТаблицеКоличествоДляЗначения1(ТЗ, "8", 5);
	ПроверитьВТаблицеКоличествоДляЗначения1(ТЗ, 8, 5);
	ПроверитьВТаблицеКоличествоДляЗначения1(ТЗ, "6", 8);
	ПроверитьВТаблицеКоличествоДляЗначения1(ТЗ, 6, 10);
КонецПроцедуры

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

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

	ТЗ.Добавить().Тест = 5;
	ТЗ.Добавить().Тест = 10;
	ТЗ.Добавить().Тест = -2;

	ТЗ.Сортировать("Тест");

	юТест.ПроверитьРавенство(ТЗ[0].Тест, -2, "ТЗ[0]");
	юТест.ПроверитьРавенство(ТЗ[1].Тест, 5, "ТЗ[1]");
	юТест.ПроверитьРавенство(ТЗ[2].Тест, 10, "ТЗ[2]");
КонецПроцедуры

Процедура ТестДолжен_ПроверитьСортировку_Булевых() Экспорт
	ТЗ = Новый ТаблицаЗначений();
	ТЗ.Колонки.Добавить("Тест");

	ТЗ.Добавить().Тест = Истина;
	ТЗ.Добавить().Тест = Ложь;
	ТЗ.Добавить().Тест = Истина;

	ТЗ.Сортировать("Тест");

	юТест.ПроверитьРавенство(ТЗ[0].Тест, Ложь, "ТЗ[0]");
	юТест.ПроверитьРавенство(ТЗ[1].Тест, Истина, "ТЗ[1]");
	юТест.ПроверитьРавенство(ТЗ[2].Тест, Истина, "ТЗ[2]");
КонецПроцедуры

Процедура ТестДолжен_ПроверитьСортировку_Дат() Экспорт
	ТЗ = Новый ТаблицаЗначений();
	ТЗ.Колонки.Добавить("Тест");

	Сегодня = ТекущаяДата();
	Пустая = '0001-01-01 00:00';
	ТЗ.Добавить().Тест = Сегодня;
	ТЗ.Добавить().Тест = Сегодня + 2;
	ТЗ.Добавить().Тест = Сегодня - 2;
	ТЗ.Добавить().Тест = Пустая;

	ТЗ.Сортировать("Тест");

	юТест.ПроверитьРавенство(ТЗ[0].Тест, Пустая, "ТЗ[0]");
	юТест.ПроверитьРавенство(ТЗ[1].Тест, Сегодня - 2, "ТЗ[1]");
	юТест.ПроверитьРавенство(ТЗ[2].Тест, Сегодня, "ТЗ[2]");
	юТест.ПроверитьРавенство(ТЗ[3].Тест, Сегодня + 2, "ТЗ[3]");
КонецПроцедуры

Процедура ТестДолжен_ПроверитьСортировку_Строк() Экспорт
	ТЗ = Новый ТаблицаЗначений();
	ТЗ.Колонки.Добавить("Тест");

	ТЗ.Добавить().Тест = "Ели";
	ТЗ.Добавить().Тест = "ежи";
	ТЗ.Добавить().Тест = "Ёлки";
	ТЗ.Добавить().Тест = "ёжики";

	ТЗ.Сортировать("Тест");

	юТест.ПроверитьРавенство(ТЗ[0].Тест, "ежи", "ТЗ[0]");
	юТест.ПроверитьРавенство(ТЗ[1].Тест, "ёжики", "ТЗ[1]");
	юТест.ПроверитьРавенство(ТЗ[2].Тест, "Ели", "ТЗ[2]");
	юТест.ПроверитьРавенство(ТЗ[3].Тест, "Ёлки", "ТЗ[3]");
КонецПроцедуры


// к issue #1577
Процедура ТестДолжен_ПроверитьСортировкуНеупорядочиваемыхТипов() Экспорт
	ТЗ = Новый ТаблицаЗначений();
	ТЗ.Колонки.Добавить("Тест");

	ТЗ.Добавить().Тест = Неопределено;
	ТЗ.Добавить().Тест = Неопределено;

	ТЗ.Сортировать("Тест"); // не должно упасть

	юТест.ПроверитьРавенство(ТЗ[0].Тест, Неопределено);
	юТест.ПроверитьРавенство(ТЗ[1].Тест, Неопределено);
КонецПроцедуры

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

	ТЗ.Добавить().Тест = Тип("Строка");
	ТЗ.Добавить().Тест = "Стр2";
	ТЗ.Добавить().Тест = "СтрЪ";
	ТЗ.Добавить().Тест = Новый Структура;
	ТЗ.Добавить().Тест = Новый Массив;
	ТЗ.Добавить().Тест = null;
	ТЗ.Добавить().Тест = Тип("Булево");
	ТЗ.Добавить().Тест = Тип("Массив");

	ТЗ.Сортировать("Тест"); // не должно упасть

	юТест.ПроверитьРавенство(ТЗ[0].Тест, Null);
	юТест.ПроверитьРавенство(ТЗ[1].Тест, "Стр2");
	юТест.ПроверитьРавенство(ТЗ[2].Тест, "СтрЪ");
	юТест.ПроверитьРавенство(ТипЗнч(ТЗ[3].Тест), Тип("Массив"));
	юТест.ПроверитьРавенство(ТипЗнч(ТЗ[4].Тест), Тип("Структура"));
	юТест.ПроверитьРавенство(ТЗ[5].Тест, Тип("Булево"));
	юТест.ПроверитьРавенство(ТЗ[6].Тест, Тип("Массив"));
	юТест.ПроверитьРавенство(ТЗ[7].Тест, Тип("Строка"));
КонецПроцедуры

Процедура ТестДолжен_ПроверитьСортировкуПоПредставлению() Экспорт
	ТЗ = Новый ТаблицаЗначений();
	ТЗ.Колонки.Добавить("Тест");

    ТекстКласса =
    	"Процедура ОбработкаПолученияПредставления(Представление, СтандартнаяОбработка)
    	|	СтандартнаяОбработка = Ложь;
    	|	Представление = ""Представление0"";
    	|КонецПроцедуры";
    КлассИзСтроки0 = ЗагрузитьСценарийИзСтроки(ТекстКласса);

    ТекстКласса =
    	"Процедура ОбработкаПолученияПредставления(Представление, СтандартнаяОбработка)
    	|	СтандартнаяОбработка = Ложь;
    	|	Представление = ""Представление1"";
    	|КонецПроцедуры";
    КлассИзСтроки1 = ЗагрузитьСценарийИзСтроки(ТекстКласса);

    ТекстКласса =
    	"Процедура ОбработкаПолученияПредставления(Представление, СтандартнаяОбработка)
    	|	СтандартнаяОбработка = Ложь;
    	|	Представление = ""Представление3"";
    	|КонецПроцедуры";
    КлассИзСтроки3 = ЗагрузитьСценарийИзСтроки(ТекстКласса);

	ТЗ.Добавить().Тест = КлассИзСтроки3;
	ТЗ.Добавить().Тест = "Представление2";
	ТЗ.Добавить().Тест = КлассИзСтроки0;
	ТЗ.Добавить().Тест = КлассИзСтроки1;
	
	ТЗ.Сортировать("Тест");
	юТест.ПроверитьРавенство(ТЗ[0].Тест, "Представление2", "строка");
	юТест.ПроверитьРавенство(Строка(ТЗ[1].Тест), "Представление0", "сценарий 0");
	юТест.ПроверитьРавенство(Строка(ТЗ[2].Тест), "Представление1", "сценарий 1");
	юТест.ПроверитьРавенство(Строка(ТЗ[3].Тест), "Представление3", "сценарий 3");
  
КонецПроцедуры

Процедура ТестДолжен_ПроверитьСортировку_СтрокРазныхАлфавитов() Экспорт
	ТЗ = Новый ТаблицаЗначений();
	ТЗ.Колонки.Добавить("Тест");

	ТЗ.Добавить().Тест = "Е"; // cyrillic
	ТЗ.Добавить().Тест = "E"; // latin
	ТЗ.Добавить().Тест = "Ε"; // greek
	ТЗ.Добавить().Тест = "∃"; // math
	ТЗ.Добавить().Тест = "Ｅ"; // full-width

	ТЗ.Сортировать("Тест");

	юТест.ПроверитьРавенство(КодСимвола(ТЗ[0].Тест,1), 8707, "math");
	юТест.ПроверитьРавенство(КодСимвола(ТЗ[1].Тест,1), 69, "latin");
	юТест.ПроверитьРавенство(КодСимвола(ТЗ[2].Тест,1), 65317, "full-width");
	юТест.ПроверитьРавенство(КодСимвола(ТЗ[3].Тест,1), 917, "greek");
	юТест.ПроверитьРавенство(КодСимвола(ТЗ[4].Тест,1), 1045, "cyrillic");
КонецПроцедуры

Процедура ТестДолжен_ПроверитьВставкуВнеРазмераТаблицы() Экспорт
	ТЗ = Новый ТаблицаЗначений();
	ТЗ.Колонки.Добавить("Тест");

	ТЗ.Добавить().Тест = -1;
	ТЗ.Вставить(8).Тест = -2;

	юТест.ПроверитьРавенство(ТЗ[1].Тест, -2);

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

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

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

Процедура ТестДолжен_ПроверитьИсключениеПриНеверномПараметреСортировки() Экспорт
	ТЗ = Новый ТаблицаЗначений();
	ТЗ.Колонки.Добавить("Тест");
	ТЗ.Добавить().Тест = 1;	
	ТЗ.Добавить().Тест = 2;
	
	Попытка
		ТЗ.Сортировать("Тест УБЫВ и_лишнее_через_пробел");
	Исключение
		Возврат;
	КонецПопытки;
	
	ВызватьИсключение "Ожидали исключение, но его не было";
КонецПроцедуры


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


Процедура ТестДолжен_Проверить_ЗаполнитьЗначения_СПустымСпискомКолонок() Экспорт
	ТЗ = Новый ТаблицаЗначений();
	ТЗ.Колонки.Добавить("Тест");
	ТЗ.Добавить().Тест = 1;	
	ТЗ.ЗаполнитьЗначения(3,"");
	
	юТест.ПроверитьРавенство(ТЗ[0].Тест, 3);
КонецПроцедуры

Процедура ТестДолжен_Проверить_Найти_СПустымСпискомКолонок() Экспорт
	ТЗ = Новый ТаблицаЗначений();
	ТЗ.Колонки.Добавить("Тест");
	ТЗ.Добавить().Тест = -3;	
	ТЗ.Добавить().Тест = 7;
	Рез = ТЗ.Найти(7,"");

	юТест.ПроверитьНеРавенство(Рез, Неопределено);
КонецПроцедуры

Процедура ТестДолжен_Проверить_СкопироватьКолонки_СПустымСпискомКолонок() Экспорт
	ТЗ = Новый ТаблицаЗначений();
	ТЗ.Колонки.Добавить("Тест");
	ТЗ.Добавить().Тест = 1;	
	ТЗ2 = ТЗ.СкопироватьКолонки();
	
	юТест.ПроверитьРавенство(ТЗ2.Колонки.Количество(), 1);
	юТест.ПроверитьРавенство(ТЗ2.Колонки[0].Имя, "Тест");
КонецПроцедуры

Процедура ТестДолжен_Проверить_Скопировать_СПустымСпискомКолонок() Экспорт
	ТЗ = Новый ТаблицаЗначений();
	ТЗ.Колонки.Добавить("Тест");
	ТЗ.Добавить().Тест = 1;	
	ТЗ.Добавить().Тест = 2;	
	ТЗ2 = ТЗ.Скопировать(,"");
	
	юТест.ПроверитьРавенство(ТЗ2.Количество(), 2);
	юТест.ПроверитьРавенство(ТЗ2.Колонки.Количество(), 1);
	юТест.ПроверитьРавенство(ТЗ2.Колонки[0].Имя, "Тест");
КонецПроцедуры

Процедура ТестДолжен_ПроверитьИтогПоКолонкеСОписаниемТипов_Строка() Экспорт
	ТЗ = Новый ТаблицаЗначений();
	ТЗ.Колонки.Добавить("Тест", Новый ОписаниеТипов("Строка"));
	ТЗ.Добавить().Тест = -3;	
	ТЗ.Добавить().Тест = "7";	
	ТЗ.Добавить().Тест = "ц5";

	юТест.ПроверитьРавенство(ТЗ.Итог("Тест"), 4);	
КонецПроцедуры

Процедура ТестДолжен_ПроверитьИтогПоКолонкеСОписаниемТипов_СтрокаЧисло() Экспорт
	ТЗ = Новый ТаблицаЗначений();
	ТЗ.Колонки.Добавить("Тест", Новый ОписаниеТипов("Строка,Число"));
	ТЗ.Добавить().Тест = -3;	
	ТЗ.Добавить().Тест = "7";	
	ТЗ.Добавить().Тест = "ц5";

	юТест.ПроверитьРавенство(ТЗ.Итог("Тест"), -3);	
КонецПроцедуры

Процедура ТестДолжен_ПроверитьИтогПоКолонкеСОписаниемТипов_СтрокаДата() Экспорт
	ТЗ = Новый ТаблицаЗначений();
	ТЗ.Колонки.Добавить("Тест", Новый ОписаниеТипов("Строка,Дата"));
	ТЗ.Добавить().Тест = -3;	
	ТЗ.Добавить().Тест = "7";	
	ТЗ.Добавить().Тест = "ц5";

	юТест.ПроверитьРавенство(ТЗ.Итог("Тест"), Неопределено);	
КонецПроцедуры

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

	юТест.ПроверитьРавенство(ТЗ.Итог("Тест"), 0);	
КонецПроцедуры

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

	юТест.ПроверитьРавенство(ТЗ.Итог("Тест"), 0);	
КонецПроцедуры

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

	юТест.ПроверитьРавенство(ТЗ.Итог("Тест"), Неопределено);	
КонецПроцедуры

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

	юТест.ПроверитьРавенство(ТЗ.Итог("Тест"), 0);	
КонецПроцедуры

Процедура ТестДолжен_ПроверитьИсключениеПриНеверномИмениКолонкиВОтборе() Экспорт
	ТЗ = Новый ТаблицаЗначений();
	ТЗ.Колонки.Добавить("Тест");
	ТЗ.Добавить().Тест = -3;	
	ТЗ.Добавить().Тест = 7;	
	Фильтр = Новый Структура("Тест,Тест2",7,7);

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

Процедура ТестДолжен_ПроверитьЗапятуюВИменахКолонок_БезПустых() Экспорт
	ТЗ = Новый ТаблицаЗначений();
	ТЗ.Колонки.Добавить("Тест");
	ТЗ.Колонки.Добавить("Тест2");
	ТЗ.Добавить().Тест = -3;	
	ТЗ.Добавить().Тест = 7;	
	ТЗ.Свернуть(", Тест" , "Тест2,");
КонецПроцедуры

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

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

Процедура ТестДолжен_ВызватьИсключениеПриДобавленииКолонкиСНевернымИменем() Экспорт
	ТЗ = Новый ТаблицаЗначений();
	Попытка
		ТЗ.Колонки.Добавить("!@#");
	Исключение
		Возврат;
	КонецПопытки;
	
	ВызватьИсключение "Должно было быть выдано исключение, но его не было";
КонецПроцедуры

Процедура ТестДолжен_ВызватьИсключениеПриВставкеКолонкиСНевернымИменем() Экспорт
	ТЗ = Новый ТаблицаЗначений();
	Попытка
		ТЗ.Колонки.Вставить(0,"!@#");
	Исключение
		Возврат;
	КонецПопытки;
	
	ВызватьИсключение "Должно было быть выдано исключение, но его не было";
КонецПроцедуры

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

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

Процедура ТестДолжен_ПроверитьИсключениеПолученияКолонкиСНевернымНомером() Экспорт
	ТЗ = Новый ТаблицаЗначений();
	ТЗ.Колонки.Добавить("Тест");
	СтрокаТЗ = ТЗ.Добавить();
	
	БылоИсключение = Ложь;
	Попытка
		Рез = СтрокаТЗ.Получить(-1);
	Исключение
		Ошибка = ИнформацияОбОшибке().Описание;
		юТест.ПроверитьНеРавенство(Найти(Ошибка,"Значение индекса выходит за пределы"), 0, "Неверный вид ошибки: "+Ошибка);
		БылоИсключение = Истина;
	КонецПопытки;
	юТест.ПроверитьИстину(БылоИсключение, "Получение колонки с неверным номером");

	БылоИсключение = Ложь;
	Попытка
		Рез = СтрокаТЗ[-1];
	Исключение
		Ошибка = ИнформацияОбОшибке().Описание;
		юТест.ПроверитьНеРавенство(Найти(Ошибка,"Значение индекса выходит за пределы"), 0, "Неверный вид ошибки: "+Ошибка);
		БылоИсключение = Истина;
	КонецПопытки;
	юТест.ПроверитьИстину(БылоИсключение, "Получение колонки по неверному индексу");

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

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

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

	КоличествоСтрок = 1000;
	Для к = 0 По КоличествоСтрок - 1 Цикл
		Стр = ТЗ.Добавить();
		Стр.СИндексом  = "Ключ" + Формат(к, "ЧГ=");
		Стр.БезИндекса = "Ключ" + Формат(к, "ЧГ=");
	КонецЦикла;

	// Поиск существующего значения по проиндексированной колонке
	ИскомыйКлюч = "Ключ" + Формат(КоличествоСтрок / 2, "ЧГ=");
	НайденнаяСтрока = ТЗ.Найти(ИскомыйКлюч, "СИндексом");
	юТест.ПроверитьЛожь(НайденнаяСтрока = Неопределено, "Строка должна быть найдена по проиндексированной колонке");
	юТест.ПроверитьРавенство(НайденнаяСтрока.СИндексом, ИскомыйКлюч, "Найденная строка должна содержать искомое значение");

	// Поиск несуществующего значения по проиндексированной колонке
	НесуществующийКлюч = "Ключ" + Формат(КоличествоСтрок + 1, "ЧГ=");
	НайденнаяСтрока = ТЗ.Найти(НесуществующийКлюч, "СИндексом");
	юТест.ПроверитьИстину(НайденнаяСтрока = Неопределено, "Несуществующее значение не должно быть найдено по проиндексированной колонке");

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

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

	ТЗ = Новый ТаблицаЗначений();
	ТЗ.Колонки.Добавить("Ключ");
	ТЗ.Индексы.Добавить("Ключ");

	Стр = ТЗ.Добавить();
	Стр.Ключ = "Существующий";

	НайденнаяСтрока = ТЗ.Найти("Несуществующий", "Ключ");
	юТест.ПроверитьИстину(НайденнаяСтрока = Неопределено, "Должно вернуть Неопределено при отсутствии совпадений");

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

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

	ТЗ = Новый ТаблицаЗначений();
	ТЗ.Колонки.Добавить("А");
	ТЗ.Колонки.Добавить("Б");
	ТЗ.Колонки.Добавить("В");

	Стр = ТЗ.Добавить();
	Стр.А = "ЗначениеА";
	Стр.Б = "ЗначениеБ";
	Стр.В = "ЗначениеВ";

	// Поиск по нескольким колонкам: значение должно совпасть хоть в одной из них
	НайденнаяСтрока = ТЗ.Найти("ЗначениеА", "А, Б");
	юТест.ПроверитьЛожь(НайденнаяСтрока = Неопределено, "Строка должна быть найдена по первой из колонок");

	НайденнаяСтрока = ТЗ.Найти("ЗначениеБ", "А, Б");
	юТест.ПроверитьЛожь(НайденнаяСтрока = Неопределено, "Строка должна быть найдена по второй из колонок");

	НайденнаяСтрока = ТЗ.Найти("ЗначениеВ", "А, Б");
	юТест.ПроверитьИстину(НайденнаяСтрока = Неопределено, "Значение из колонки В не должно найтись при поиске по А и Б");

	// Поиск без указания колонок — по всем
	НайденнаяСтрока = ТЗ.Найти("ЗначениеВ");
	юТест.ПроверитьЛожь(НайденнаяСтрока = Неопределено, "Строка должна быть найдена при поиске по всем колонкам");

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

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

	// Индекс только по «Цвет»; Найти ищет по ИЛИ в «Товар, Цвет» — первая подходящая строка в порядке таблицы
	ТЗ = Новый ТаблицаЗначений();
	ТЗ.Колонки.Добавить("Товар");
	ТЗ.Колонки.Добавить("Цвет");
	ТЗ.Индексы.Добавить("Цвет");

	С1 = ТЗ.Добавить();
	С1.Товар = "Иск";
	С1.Цвет = "Красный";

	С2 = ТЗ.Добавить();
	С2.Товар = "Другой";
	С2.Цвет = "Иск";

	НайденнаяСтрока = ТЗ.Найти("Иск", "Товар, Цвет");
	юТест.ПроверитьЛожь(НайденнаяСтрока = Неопределено, "Должна находиться строка по совпадению в колонке «Товар»");
	юТест.ПроверитьРавенство(НайденнаяСтрока, С1, "При совпадении в первой колонке раньше по порядку — первая строка");

	НайденнаяСтрока = ТЗ.Найти("Синий", "Товар, Цвет");
	юТест.ПроверитьИстину(НайденнаяСтрока = Неопределено, "Нет совпадений ни в одной из колонок");

	С3 = ТЗ.Добавить();
	С3.Товар = "Третий";
	С3.Цвет = "Синий";

	НайденнаяСтрока = ТЗ.Найти("Синий", "Товар, Цвет");
	юТест.ПроверитьЛожь(НайденнаяСтрока = Неопределено, "Совпадение только в проиндексированной колонке «Цвет»");
	юТест.ПроверитьРавенство(НайденнаяСтрока, С3);

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

Процедура ТестДолжен_НайтиСИндексомБыстрееЧемБезИндекса() Экспорт

	КоличествоСтрок = 10000;
	КоличествоИзмерений = 100;

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

	ИскомоеЗначение = Неопределено;
	Для к = 1 По КоличествоСтрок Цикл
		UID = Новый УникальныйИдентификатор();
		Стр = ТЗ.Добавить();
		Стр.СИндексом  = Строка(UID);
		Стр.БезИндекса = Строка(UID);
		Если к = КоличествоСтрок / 2 Тогда
			ИскомоеЗначение = Строка(UID);
		КонецЕсли;
	КонецЦикла;

	// Замер поиска БЕЗ индекса
	НачалоБезИндекса = ТекущаяУниверсальнаяДатаВМиллисекундах();
	Для Ит = 1 По КоличествоИзмерений Цикл
		ТЗ.Найти(ИскомоеЗначение, "БезИндекса");
	КонецЦикла;
	ВремяБезИндекса = ТекущаяУниверсальнаяДатаВМиллисекундах() - НачалоБезИндекса;

	// Замер поиска С индексом
	НачалоСИндексом = ТекущаяУниверсальнаяДатаВМиллисекундах();
	Для Ит = 1 По КоличествоИзмерений Цикл
		ТЗ.Найти(ИскомоеЗначение, "СИндексом");
	КонецЦикла;
	ВремяСИндексом = ТекущаяУниверсальнаяДатаВМиллисекундах() - НачалоСИндексом;

	юТест.ПроверитьИстину(
		ВремяСИндексом < ВремяБезИндекса,
		"Поиск с индексом (" + ВремяСИндексом + " мс) должен быть быстрее поиска без индекса (" + ВремяБезИндекса + " мс)"
	);

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