
Функция Конт(Конт) Возврат Конт; КонецФункции
Функция Сам() Возврат Конт(Контекст); КонецФункции //:Контекст
//_____________________________________________________________________________
Функция ТЗ()
	Возврат СоздатьОбъект("ИндексированнаяТаблица");
КонецФункции

//_____________________________________________________________________________
Функция сз(п1, п2, п3 = "")
	Сп = СоздатьОбъект("СписокЗначений");
	Сп.ДобавитьЗначение(п1);
	Сп.ДобавитьЗначение(п2);
	Сп.ДобавитьЗначение(п3);
	Возврат Сп;
КонецФункции

Процедура _ДобавитьСтроку(__т, __знач1, __знач2)
	__т.НоваяСтрока();
	__т.УстановитьЗначение(__т.НомерСтроки, 1, __знач1);
	__т.УстановитьЗначение(__т.НомерСтроки, 2, __знач2);
КонецПроцедуры

//_____________________________________________________________________________
Функция Выборка_ЗаполнитьТЗ()
	ТЗ = ТЗ();
	ТЗ.НоваяКолонка("К1");
	ТЗ.НоваяКолонка("К2");

	ТЗ.НоваяСтрока(); //1
	ТЗ.к1 = 5; ТЗ.к2 = 1;

	ТЗ.НоваяСтрока(); //2
	ТЗ.к1 = 15;

	ТЗ.НоваяСтрока(); //3
	ТЗ.к1 = 5; ТЗ.к2 = 2;

	ТЗ.НоваяСтрока(); //4
	ТЗ.к1 = 10;

	ТЗ.НоваяСтрока(); //5
	ТЗ.к1 = 1;
	Возврат ТЗ;
КонецФункции

//_____________________________________________________________________________
Функция Док(ДатаДок, НомерДок)
	Док = СоздатьОбъект("Документ.Новый1");
	Док.Новый();
	Док.ДатаДок = ДатаДок;
	Док.НомерДок = НомерДок;
	Док.Записать();
	Возврат Док.ТекущийДокумент();
КонецФункции

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

	ТЗ.НоваяСтрока(); //1
	ТЗ.Док = Док('03.01.2005', 4);

	ТЗ.НоваяСтрока(); //2
	ТЗ.Док = Док('03.01.2005', 3);

	ТЗ.НоваяСтрока(); //3
	ТЗ.Док = Док('01.01.2005', 9);
	Док = ТЗ.Док;

	ТЗ.НоваяСтрока(); //4
	ТЗ.Док = Док;

	ТЗ.НоваяСтрока(); //5
	Док = Док('02.01.2005', 1);
	ТЗ.Док = Док;

	ТЗ.НоваяСтрока(); //6
	ТЗ.Док = Док;

	ТЗ.ВыбратьСтроки();
	Пока ТЗ.ПолучитьСтроку() = 1 Цикл
		ТЗ.стрДок = ""+ТЗ.Док;
		ТЗ.ДатаДок = ТЗ.Док.ДатаДок;
		ТЗ.Позиция = СформироватьПозициюДокумента(ТЗ.Док);
		ТЗ.к1 = ТЗ.НомерСтроки;
		ТЗ.к2 = ТЗ.НомерСтроки * 2;
	КонецЦикла;

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

//_____________________________________________________________________________
Функция Спр(Наименование, Код, Родитель = "")
	Спр = СоздатьОбъект("Справочник.Новый1");
	Спр.Новый();
	Если ПустоеЗначение(Родитель) = 0 Тогда
		Спр.Родитель = Родитель;
	КонецЕсли;
	Спр.Наименование = Наименование;
	Спр.Код = Код;
	Спр.Записать();
	Возврат Спр.ТекущийЭлемент();
КонецФункции

//_____________________________________________________________________________
Функция Выборка_ЗаполнитьТЗ_Спр()
	ТЗ = ТЗ();
	ТЗ.НоваяКолонка("Спр");
	ТЗ.НоваяКолонка("стрСпр");
	ТЗ.НоваяКолонка("К1");
	ТЗ.НоваяКолонка("К2");

	ТЗ.НоваяСтрока(); //1
	ТЗ.Спр = Спр("1 Запись 5", 5);

	ТЗ.НоваяСтрока(); //2
	ТЗ.Спр = Спр("1 Запись 1", 1);

	ТЗ.НоваяСтрока(); //3
	ТЗ.Спр = Спр("3 Запись 6", 6);

	ТЗ.НоваяСтрока(); //4
	ТЗ.Спр = Спр("2 Запись 7", 7);

	ТЗ.НоваяСтрока(); //5
	ТЗ.Спр = Спр("4 Запись 2", 2);

	ТЗ.ВыбратьСтроки();
	Пока ТЗ.ПолучитьСтроку() = 1 Цикл
		ТЗ.стрСпр = ""+ТЗ.Спр;
		ТЗ.к1 = ТЗ.НомерСтроки;
		ТЗ.к2 = ТЗ.НомерСтроки * 2;
	КонецЦикла;

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

//_____________________________________________________________________________
Процедура ВывестиТЗ(ТЗ, Индекс = "")
	ТЗ.ВыбратьСтроки(Индекс);
	Пока ТЗ.ПолучитьСтроку(Индекс) = 1 Цикл
		Сообщить(""+ТЗ.НомерСтроки+": "+ТЗ.к1+"  ("+ТипЗначенияСтр(ТЗ.к1)+")");
	КонецЦикла;
КонецПроцедуры

//_____________________________________________________________________________
Процедура _РедакторТЗ(ТЗ, Индекс = "")
	_ТЗ = СоздатьОбъект("ТаблицаЗначений");
	ТЗ.Выгрузить(_ТЗ, Индекс);
	РедакторТЗ(_ТЗ);
КонецПроцедуры


//_____________________________________________________________________________
Процедура тестСоздатьСтроку() Экспорт
	ТЗ = ТЗ();
	Сам().ПроверитьРавенство(ТЗ.НоваяСтрока(), 1);
	Сам().ПроверитьРавенство(ТЗ.НоваяСтрока(), 2);
КонецПроцедуры


//_____________________________________________________________________________
Процедура тестНомерСтроки() Экспорт
	Сам = Сам();
	ТЗ = ТЗ();

	ТЗ.НоваяКолонка("К1");

	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 0);
	ТЗ.НоваяСтрока();
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 1);
	ТЗ.К1 = 1;

	ТЗ.НоваяСтрока();
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 2);
	ТЗ.к1 = 10;

	Сам.ПроверитьРавенство(ТЗ.к1, 10);

	ТЗ.НомерСтроки = 1;
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 1);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестНомерСтрокиСИндексом() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();

	ТЗ.ДобавитьИндекс("Инд1", "к1");
	ТЗ.ДобавитьИндекс("Инд2", "к2,к1");

	ТЗ.ВыбратьСтроки("Инд1");
	ТЗ.ПолучитьСтроку("Инд1");
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 5);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки("Инд1"), 5);
	ТЗ.ПолучитьСтроку("Инд1");
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 1);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки("Инд1"), 1);

	ТЗ.ВыбратьСтроки("Инд2");
	ТЗ.ПолучитьСтроку("Инд2");
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 5);
	Сам.ПроверитьРавенство(ТЗ.к1, 1);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки("Инд2"), 5);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки("Инд1"), 1);

	ТЗ.ПолучитьСтроку("Инд2");
	Сам.ПроверитьРавенство(ТЗ.к1, 10);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 4);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки("Инд2"), 4);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки("Инд1"), 1);

	ТЗ.ПолучитьСтроку("Инд2");
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 2);
	Сам.ПроверитьРавенство(ТЗ.к1, 15);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки("Инд2"), 2);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки("Инд1"), 1);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестКоличествоСтрок() Экспорт
	Сам = Сам();
	ТЗ = ТЗ();

	ТЗ.НоваяКолонка("К1");

	Сам.ПроверитьРавенство(ТЗ.КоличествоСтрок(), 0);
	ТЗ.НоваяСтрока();
	Сам.ПроверитьРавенство(ТЗ.КоличествоСтрок(), 1);
	ТЗ.НоваяСтрока();
	Сам.ПроверитьРавенство(ТЗ.КоличествоСтрок(), 2);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестКоличествоСтрокПоИндексу() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();
	ТЗ.ДобавитьИндекс("к1","к1", 0); // БЕЗ УНИКАЛЬНОСТИ
	Сам.ПроверитьРавенство(ТЗ.КоличествоСтрок("к1"), 5);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестКоличествоСтрокПоИндексуСУникальнымиЗначениями() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();
	ТЗ.ДобавитьИндекс("к1","к1", 1); // С УНИКАЛЬНЫМИ КЛЮЧАМИ
	Сам.ПроверитьРавенство(ТЗ.КоличествоСтрок("к1"), 4);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестКоличествоСтрокПоФильтру() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();
	ТЗ.Сортировать("к1");
	ТЗ.УстановитьФильтр(5, 11);
	Сам.ПроверитьРавенство(ТЗ.КоличествоСтрок(), 3);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестСоздатьКолонку() Экспорт
	ТЗ = ТЗ();
	Сам().ПроверитьРавенство(ТЗ.НоваяКолонка("К1"), 1);
	Сам().ПроверитьРавенство(ТЗ.НоваяКолонка("К2"), 2);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестСоздатьМногоКолонок() Экспорт
	ТЗ = ТЗ();
	Сам().ПроверитьРавенство(ТЗ.НоваяКолонка("К1"), 1);
	Сам().ПроверитьРавенство(ТЗ.НоваяКолонка("К2"), 2);
	Сам().ПроверитьРавенство(ТЗ.НоваяКолонка("К3"), 3);
	Сам().ПроверитьРавенство(ТЗ.НоваяКолонка("К4"), 4);
	Сам().ПроверитьРавенство(ТЗ.НоваяКолонка("К5"), 5);
	Сам().ПроверитьРавенство(ТЗ.НоваяКолонка("К6"), 6);
	Сам().ПроверитьРавенство(ТЗ.НоваяКолонка("К7"), 7);
	Сам().ПроверитьРавенство(ТЗ.НоваяКолонка("К8"), 8);
	Сам().ПроверитьРавенство(ТЗ.НоваяКолонка("К9"), 9);
	Сам().ПроверитьРавенство(ТЗ.НоваяКолонка("К10"), 10);
	Сам().ПроверитьРавенство(ТЗ.НоваяКолонка("К11"), 11);
	Сам().ПроверитьРавенство(ТЗ.НоваяКолонка("К12"), 12);
	Сам().ПроверитьРавенство(ТЗ.НоваяКолонка("К13"), 13);
	Сам().ПроверитьРавенство(ТЗ.НоваяКолонка("К14"), 14);
	Сам().ПроверитьРавенство(ТЗ.НоваяКолонка("К15"), 15);
	Сам().ПроверитьРавенство(ТЗ.НоваяКолонка("К16"), 16);
	Сам().ПроверитьРавенство(ТЗ.НоваяКолонка("К17"), 17);
	Сам().ПроверитьРавенство(ТЗ.НоваяКолонка("К18"), 18);
	Сам().ПроверитьРавенство(ТЗ.НоваяКолонка("К19"), 19);
	Сам().ПроверитьРавенство(ТЗ.НоваяКолонка("К20"), 20);

	ТЗ.НоваяСтрока();
	ТЗ.к10 = 10;
	ТЗ.к11 = 11;
	ТЗ.к12 = 12;
	ТЗ.к13 = 13;
	ТЗ.к14 = 14;
	ТЗ.к15 = 15;
	ТЗ.к16 = 16;
	ТЗ.к17 = 17;
	ТЗ.к18 = 18;
	ТЗ.к19 = 19;
	ТЗ.к20 = 20;
	Сам().ПроверитьРавенство(ТЗ.К10, 10);
	Сам().ПроверитьРавенство(ТЗ.К11, 11);
	Сам().ПроверитьРавенство(ТЗ.К12, 12);
	Сам().ПроверитьРавенство(ТЗ.К13, 13);
	Сам().ПроверитьРавенство(ТЗ.К14, 14);
	Сам().ПроверитьРавенство(ТЗ.К15, 15);
	Сам().ПроверитьРавенство(ТЗ.К16, 16);
	Сам().ПроверитьРавенство(ТЗ.К17, 17);
	Сам().ПроверитьРавенство(ТЗ.К18, 18);
	Сам().ПроверитьРавенство(ТЗ.К19, 19);
	Сам().ПроверитьРавенство(ТЗ.К17, 17);
	Сам().ПроверитьРавенство(ТЗ.К20, 20);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестКоличествоКолонок() Экспорт
	ТЗ = ТЗ();
	Сам().ПроверитьРавенство(ТЗ.КоличествоКолонок(), 0);
	ТЗ.НоваяКолонка("К1");
	Сам().ПроверитьРавенство(ТЗ.КоличествоКолонок(), 1);
	ТЗ.НоваяКолонка("К2");
	Сам().ПроверитьРавенство(ТЗ.КоличествоКолонок(), 2);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестИмяКолонки() Экспорт
	ТЗ = ТЗ();
	ТЗ.НоваяКолонка("К1");
	Сам().ПроверитьРавенство(ТЗ.ИмяКолонки(1), "К1");
КонецПроцедуры

//_____________________________________________________________________________
Процедура НовКол(Сп) Экспорт
	Сп.ПолучитьЗначение(1).НоваяКолонка(Сп.ПолучитьЗначение(2));
КонецПроцедуры
//_____________________________________________________________________________
Процедура тестСоздатьКолонку_Ошибка() Экспорт
	ТЗ = ТЗ();

	Сам().ПроверитьРавенство(ТЗ.НоваяКолонка("К1"), 1);
	Сам().ПроверитьРавенство(ТЗ.НоваяКолонка("К2"), 2);

	Сам().ПроверитьИсключение(Сам(), "НовКол", Сз(ТЗ, "К1"));
	//Сам().ПроверитьИсключение(Сам(), "НовКол", "/К2");
	Сам().ПроверитьИсключение(Сам(), "НовКол", ПолучитьПустоеЗначение());
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестПереименоватьКолонку() Экспорт
	Сам = Сам();
	
	ТЗ = Выборка_ЗаполнитьТЗ();
	ТЗ.ВыбратьСтроки();
	Пока ТЗ.ПолучитьСтроку() = 1 Цикл
		ТЗ.к2 = ТЗ.НомерСтроки;
	КонецЦикла;
	
	ТЗ.ПереименоватьКолонку("к2", "к2_нов");
	Сам.ПроверитьРавенство(ТЗ.НомерКолонки("к2_нов"), 2);
	ТЗ.НомерСтроки = 1;
	Сам.ПроверитьРавенство(ТЗ.к2_нов, 1);
	
	//--------------------------------------------------
	ТЗ.ДобавитьИндекс("и1", "к2_нов");
	ТЗ.ВыбратьСтроки("и1");
	ТЗ.ПолучитьСтроку("и1");
	Сам.ПроверитьРавенство(ТЗ.к2_нов, 1);
	ТЗ.ПолучитьСтроку("и1");
	Сам.ПроверитьРавенство(ТЗ.к2_нов, 2);
	ТЗ.ПолучитьСтроку("и1");
	Сам.ПроверитьРавенство(ТЗ.к2_нов, 3);

	//--------------------------------------------------
	ТЗ.ПереименоватьКолонку("к2_нов", "к2_нов_нов");
	
	ТЗ.ПолучитьСтроку("и1");
	Сам.ПроверитьРавенство(ТЗ.к2_нов_нов, 4);
	
	ТЗ.ВыбратьСтроки("и1");
	ТЗ.ПолучитьСтроку("и1");
	Сам.ПроверитьРавенство(ТЗ.к2_нов_нов, 1);
	ТЗ.ПолучитьСтроку("и1");
	Сам.ПроверитьРавенство(ТЗ.к2_нов_нов, 2);
	ТЗ.ПолучитьСтроку("и1");
	Сам.ПроверитьРавенство(ТЗ.к2_нов_нов, 3);
КонецПроцедуры

//_____________________________________________________________________________
Процедура ПереименоватьКолонку_Ошибка(ТЗ) Экспорт
	ТЗ.ПереименоватьКолонку("к1", "к2");
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестПереименоватьКолонку_Ошибка() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();
	Сам.ПроверитьИсключение(Сам, "ПереименоватьКолонку_Ошибка", ТЗ);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестУдалитьКолонку1() Экспорт
	Сам = Сам();
	ТЗ = ТЗ();

	ТЗ.НоваяКолонка("к1");
	ТЗ.НоваяКолонка("к2");
	ТЗ.НоваяСтрока();
	Сам().ПроверитьРавенство(ТЗ.КоличествоКолонок(), 2);
	ТЗ.УдалитьКолонку("к2");
	Сам().ПроверитьРавенство(ТЗ.КоличествоКолонок(), 1);
	ТЗ.УдалитьКолонку(1);
	Сам().ПроверитьРавенство(ТЗ.КоличествоКолонок(), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестУдалитьКолонку2() Экспорт
	Сам = Сам();
	ТЗ = ТЗ();

	ТЗ.НоваяКолонка("к1");
	ТЗ.НоваяКолонка("к2");
	ТЗ.НоваяКолонка("к3");
	ТЗ.НоваяСтрока();

	ТЗ.УдалитьКолонку("к1");
	Сам().ПроверитьРавенство(ТЗ.ИмяКолонки(1), "к2");
	Сам().ПроверитьРавенство(ТЗ.ИмяКолонки(2), "к3");

	ТЗ.УдалитьКолонку(1);
	Сам().ПроверитьРавенство(ТЗ.ИмяКолонки(1), "к3");
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестУдалитьКолонку_Ошибка() Экспорт
	Сам = Сам();
	ТЗ = ТЗ();

	ТЗ.НоваяКолонка("к1");
	ТЗ.НоваяКолонка("к2");
	ТЗ.НоваяСтрока();
	Сам().ПроверитьРавенство(ТЗ.КоличествоКолонок(), 2);

	ТЗ.ДобавитьИндекс("Индекс1", "к1, к2");

	Сам().ПроверитьИсключение(ТЗ, "УдалитьКолонку", "к2");
	Сам().ПроверитьИсключение(ТЗ, "УдалитьКолонку", "к3");
	Сам().ПроверитьИсключение(ТЗ, "УдалитьКолонку", 0);
	Сам().ПроверитьИсключение(ТЗ, "УдалитьКолонку", 1);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестЗаполнитьСтроку() Экспорт
	Сам = Сам();
	ТЗ = ТЗ();
	ТЗ.НоваяКолонка("к1");
	ТЗ2 = Выборка_ЗаполнитьТЗ();

	ТЗ.НоваяСтрока();
	ТЗ.ЗаполнитьСтроку(, ТЗ2, 1);
	Сам.ПроверитьРавенство(ТЗ.к1, ТЗ2.Получить(1, 1));

	ТЗ.НоваяКолонка("к3");
	ТЗ.НоваяСтрока();
	ТЗ.ЗаполнитьСтроку(, ТЗ2, 1);
	Сам.ПроверитьРавенство(ТЗ.к1, ТЗ2.Получить(1, 1));
	Сам.ПроверитьРавенство(ТЗ.к3, ТЗ2.Получить(1, 2));

	ТЗ.НоваяКолонка("к2");
	ТЗ.НоваяСтрока();
	ТЗ.ЗаполнитьСтроку(, ТЗ2, 1);
	Сам.ПроверитьРавенство(ТЗ.к1, ТЗ2.Получить(1, 1));
	Сам.ПроверитьРавенство(ТЗ.к2, ПолучитьПустоеЗначение());
	Сам.ПроверитьРавенство(ТЗ.к3, ТЗ2.Получить(1, 2));

	н = ТЗ.НоваяСтрока();
	ТЗ.ЗаполнитьСтроку(н, ТЗ2, 1, 1); //по именам колонок
	Сам.ПроверитьРавенство(ТЗ.к1, ТЗ2.Получить(1, 1));
	Сам.ПроверитьРавенство(ТЗ.к2, ТЗ2.Получить(1, 2));
	Сам.ПроверитьРавенство(ТЗ.к3, ПолучитьПустоеЗначение());
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестЗаполнитьСтрокуИзСебя() Экспорт
	Сам = Сам();
	ТЗ = ТЗ();
	ТЗ.НоваяКолонка("к1");
	ТЗ.НоваяКолонка("к2");
	ТЗ.НоваяКолонка("к3");

	н = ТЗ.НоваяСтрока();
	ТЗ.к1 = 10; ТЗ.к2 = 20; ТЗ.к3 = 30;

	ТЗ.НоваяСтрока();
	ТЗ.ЗаполнитьСтроку(, ТЗ, н, 0);
	Сам.ПроверитьРавенство(ТЗ.к1, 10);
	Сам.ПроверитьРавенство(ТЗ.к2, 20);
	Сам.ПроверитьРавенство(ТЗ.к3, 30);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестЗаполнитьСтрокуСЗ() Экспорт
	Сам = Сам();
	ТЗ = ТЗ();
	ТЗ.НоваяКолонка("к1");
	ТЗ.НоваяКолонка("к2");
	ТЗ.НоваяКолонка("к3");

	Сп = СоздатьОбъект("СписокЗначений");
	Сп.ДобавитьЗначение(1);
	Сп.ДобавитьЗначение(2);
	Сп.ДобавитьЗначение(3);
	Сп.Установить("к2", 4);
	Сп.Установить("к3", 5);
	Сп.Установить("к1", 6);

	ТЗ.НоваяСтрока();
	ТЗ.ЗаполнитьСтроку(, Сп);
	Сам.ПроверитьРавенство(ТЗ.Получить(, 1), 1);
	Сам.ПроверитьРавенство(ТЗ.Получить(, 2), 2);
	Сам.ПроверитьРавенство(ТЗ.Получить(, 3), 3);

	ТЗ.НоваяСтрока();
	ТЗ.ЗаполнитьСтроку(, Сп,, 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 6);
	Сам.ПроверитьРавенство(ТЗ.к2, 4);
	Сам.ПроверитьРавенство(ТЗ.к3, 5);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестЗаполнитьСтрокуТЗ() Экспорт
	Сам = Сам();

	_ТЗ = СоздатьОбъект("ТаблицаЗначений");
	_ТЗ.НоваяКолонка("к3");
	_ТЗ.НоваяКолонка("к2");
	_ТЗ.НоваяКолонка("к1");
	_ТЗ.НоваяСтрока();
	_ТЗ.к3 = 1;
	_ТЗ.к2 = 2;
	_ТЗ.к1 = 3;

	ТЗ = СоздатьОбъект("ИндексированнаяТаблица");
	ТЗ.НоваяКолонка("к1");
	ТЗ.НоваяКолонка("к2");
	ТЗ.НоваяКолонка("к3");

	ТЗ.НоваяСтрока();
	ТЗ.ЗаполнитьСтроку(, _ТЗ, 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 1);
	Сам.ПроверитьРавенство(ТЗ.к2, 2);
	Сам.ПроверитьРавенство(ТЗ.к3, 3);

	// падает при несовпадении количества колонок
	_ТЗ.НоваяКолонка("к4");

	ТЗ.НоваяСтрока();

	ТЗ.ЗаполнитьСтроку(, _ТЗ, 1, 1);

	Сам.ПроверитьРавенство(ТЗ.к1, 3);
	Сам.ПроверитьРавенство(ТЗ.к2, 2);
	Сам.ПроверитьРавенство(ТЗ.к3, 1);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестЗаполнитьСтрокуЗнач() Экспорт
	Сам = Сам();

	ТЗ = СоздатьОбъект("ИндексированнаяТаблица");
	ТЗ.НоваяКолонка("к1");
	ТЗ.НоваяКолонка("к2");
	ТЗ.НоваяКолонка("к3");

	ТЗ.НоваяСтрока();
	ТЗ.ЗаполнитьСтроку(, 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 1);
	Сам.ПроверитьРавенство(ТЗ.к2, 1);
	Сам.ПроверитьРавенство(ТЗ.к3, 1);

	ТЗ.НоваяСтрока();
	ТЗ.ЗаполнитьСтроку(, 2);
	Сам.ПроверитьРавенство(ТЗ.к1, 2);
	Сам.ПроверитьРавенство(ТЗ.к2, 2);
	Сам.ПроверитьРавенство(ТЗ.к3, 2);

	ТЗ.ЗаполнитьСтроку(, 2, 2);
	Сам.ПроверитьРавенство(ТЗ.к1, 2);
	Сам.ПроверитьРавенство(ТЗ.к2, 2);
	Сам.ПроверитьРавенство(ТЗ.к3, 2);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестЗаполнитьКолонкуЗнач() Экспорт
	Сам = Сам();

	ТЗ = СоздатьОбъект("ИндексированнаяТаблица");
	ТЗ.НоваяКолонка("к1");
	ТЗ.НоваяКолонка("к2");
	ТЗ.НоваяКолонка("к3");

	Для н = 1 По 6 Цикл
		ТЗ.НоваяСтрока();
		ТЗ.к1 = н;
		ТЗ.к2 = 0;
		ТЗ.к3 = 0;
	КонецЦикла;

	ТЗ.ДобавитьИндекс("и1", "к1");
	ТЗ.УстановитьФильтр(3, 4, "и1");

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

//_____________________________________________________________________________
Процедура тестЗаполнитьКолонкуСЗ() Экспорт
	Сам = Сам();

	ТЗ = СоздатьОбъект("ИндексированнаяТаблица");
	ТЗ.НоваяКолонка("к1");
	ТЗ.НоваяКолонка("к2");
	ТЗ.НоваяКолонка("к3");

	Для н = 1 По 6 Цикл
		ТЗ.НоваяСтрока();
		ТЗ.к1 = н;
		ТЗ.к2 = 0;
		ТЗ.к3 = 0;
	КонецЦикла;

	ТЗ.ДобавитьИндекс("и1", "к1");
	ТЗ.УстановитьФильтр(2, 4, "и1");

	Сз = СоздатьОбъект("СписокЗначений");
	Сз.ДобавитьЗначение(4);
	Сз.ДобавитьЗначение(6);
	Сз.ДобавитьЗначение(8);
	Сз.ДобавитьЗначение(10);
	Сз.ДобавитьЗначение(12);

	ТЗ.ЗаполнитьКолонку("и1", "к2", Сз);
	Сам.ПроверитьРавенство(ТЗ.Получить(1, "к2"), 0);
	Сам.ПроверитьРавенство(ТЗ.Получить(2, "к2"), 4);
	Сам.ПроверитьРавенство(ТЗ.Получить(3, "к2"), 6);
	Сам.ПроверитьРавенство(ТЗ.Получить(4, "к2"), 8);
	Сам.ПроверитьРавенство(ТЗ.Получить(5, "к2"), 0);
	Сам.ПроверитьРавенство(ТЗ.Получить(6, "к2"), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестЗаполнитьКолонкуТЗ() Экспорт
	Сам = Сам();

	ТЗ = СоздатьОбъект("ИндексированнаяТаблица");
	ТЗ.НоваяКолонка("к1");
	ТЗ.НоваяКолонка("к2");
	ТЗ.НоваяКолонка("к3");

	_ТЗ = СоздатьОбъект("ТаблицаЗначений");
	_ТЗ.НоваяКолонка("к1");
	_ТЗ.НоваяКолонка("к2");
	_ТЗ.НоваяКолонка("к3");

	Для н = 1 По 6 Цикл
		ТЗ.НоваяСтрока();
		ТЗ.к1 = н;
		ТЗ.к2 = 0;
		ТЗ.к3 = 0;

		_ТЗ.НоваяСтрока();
		_ТЗ.к1 = н;
		_ТЗ.к2 = н*2;
		_ТЗ.к3 = н*4;
	КонецЦикла;

	ТЗ.ДобавитьИндекс("и1", "к1");
	ТЗ.УстановитьФильтр(2, 4, "и1");

	ТЗ.ЗаполнитьКолонку("и1", "к2", _ТЗ, "к2");
	Сам.ПроверитьРавенство(ТЗ.Получить(1, "к2"), 0);
	Сам.ПроверитьРавенство(ТЗ.Получить(2, "к2"), 2);
	Сам.ПроверитьРавенство(ТЗ.Получить(3, "к2"), 4);
	Сам.ПроверитьРавенство(ТЗ.Получить(4, "к2"), 6);
	Сам.ПроверитьРавенство(ТЗ.Получить(5, "к2"), 0);
	Сам.ПроверитьРавенство(ТЗ.Получить(6, "к2"), 0);

	ТЗ.ЗаполнитьКолонку("и1", "к2", _ТЗ, "к3");
	Сам.ПроверитьРавенство(ТЗ.Получить(1, "к2"), 0);
	Сам.ПроверитьРавенство(ТЗ.Получить(2, "к2"), 4);
	Сам.ПроверитьРавенство(ТЗ.Получить(3, "к2"), 8);
	Сам.ПроверитьРавенство(ТЗ.Получить(4, "к2"), 12);
	Сам.ПроверитьРавенство(ТЗ.Получить(5, "к2"), 0);
	Сам.ПроверитьРавенство(ТЗ.Получить(6, "к2"), 0);

	ТЗ.ЗаполнитьКолонку("и1", "к3", _ТЗ);
	Сам.ПроверитьРавенство(ТЗ.Получить(1, "к3"), 0);
	Сам.ПроверитьРавенство(ТЗ.Получить(2, "к3"), 4);
	Сам.ПроверитьРавенство(ТЗ.Получить(3, "к3"), 8);
	Сам.ПроверитьРавенство(ТЗ.Получить(4, "к3"), 12);
	Сам.ПроверитьРавенство(ТЗ.Получить(5, "к3"), 0);
	Сам.ПроверитьРавенство(ТЗ.Получить(6, "к3"), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестЗаполнитьКолонкуИндТЗ() Экспорт
	Сам = Сам();

	ТЗ = СоздатьОбъект("ИндексированнаяТаблица");
	ТЗ.НоваяКолонка("к1");
	ТЗ.НоваяКолонка("к2");
	ТЗ.НоваяКолонка("к3");

	_ТЗ = СоздатьОбъект("ИндексированнаяТаблица");
	_ТЗ.НоваяКолонка("к1");
	_ТЗ.НоваяКолонка("к2");
	_ТЗ.НоваяКолонка("к3");

	Для н = 1 По 6 Цикл
		ТЗ.НоваяСтрока();
		ТЗ.к1 = н;
		ТЗ.к2 = 0;
		ТЗ.к3 = 0;

		_ТЗ.НоваяСтрока();
		_ТЗ.к1 = н;
		_ТЗ.к2 = н*2;
		_ТЗ.к3 = н*4;
	КонецЦикла;

	ТЗ.ДобавитьИндекс("и1", "к1");
	ТЗ.УстановитьФильтр(2, 4, "и1");

	_ТЗ.ДобавитьИндекс("и1", "к1");
	_ТЗ.УстановитьФильтр(3, 6, "и1");

	ТЗ.ЗаполнитьКолонку("и1", "к2", _ТЗ, "и1", "к2");
	Сам.ПроверитьРавенство(ТЗ.Получить(1, "к2"), 0);
	Сам.ПроверитьРавенство(ТЗ.Получить(2, "к2"), 6);
	Сам.ПроверитьРавенство(ТЗ.Получить(3, "к2"), 8);
	Сам.ПроверитьРавенство(ТЗ.Получить(4, "к2"), 10);
	Сам.ПроверитьРавенство(ТЗ.Получить(5, "к2"), 0);
	Сам.ПроверитьРавенство(ТЗ.Получить(6, "к2"), 0);

	ТЗ.ЗаполнитьКолонку("и1", "к2", _ТЗ, "и1", "к3");
	Сам.ПроверитьРавенство(ТЗ.Получить(1, "к2"), 0);
	Сам.ПроверитьРавенство(ТЗ.Получить(2, "к2"), 12);
	Сам.ПроверитьРавенство(ТЗ.Получить(3, "к2"), 16);
	Сам.ПроверитьРавенство(ТЗ.Получить(4, "к2"), 20);
	Сам.ПроверитьРавенство(ТЗ.Получить(5, "к2"), 0);
	Сам.ПроверитьРавенство(ТЗ.Получить(6, "к2"), 0);

	ТЗ.ЗаполнитьКолонку("и1", "к3", _ТЗ, "и1");
	Сам.ПроверитьРавенство(ТЗ.Получить(1, "к3"), 0);
	Сам.ПроверитьРавенство(ТЗ.Получить(2, "к3"), 12);
	Сам.ПроверитьРавенство(ТЗ.Получить(3, "к3"), 16);
	Сам.ПроверитьРавенство(ТЗ.Получить(4, "к3"), 20);
	Сам.ПроверитьРавенство(ТЗ.Получить(5, "к3"), 0);
	Сам.ПроверитьРавенство(ТЗ.Получить(6, "к3"), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестЗаполнитьКолонкуСИзменеиемИндекса() Экспорт
	Сам = Сам();

	ТЗ = СоздатьОбъект("ИндексированнаяТаблица");
	ТЗ.НоваяКолонка("к1");
	ТЗ.НоваяКолонка("к2");
	ТЗ.НоваяКолонка("к3");

	Для н = 1 По 6 Цикл
		ТЗ.НоваяСтрока();
		ТЗ.к1 = н;
		ТЗ.к2 = 0;
		ТЗ.к3 = 0;
	КонецЦикла;

	ТЗ.ДобавитьИндекс("и1", "к1");
	ТЗ.УстановитьФильтр(3, 4, "и1");

	ТЗ.ЗаполнитьКолонку("и1", "к1", 10);
	Сам.ПроверитьРавенство(ТЗ.Получить(1, "к1"), 1);
	Сам.ПроверитьРавенство(ТЗ.Получить(2, "к1"), 2);
	Сам.ПроверитьРавенство(ТЗ.Получить(3, "к1"), 10);
	Сам.ПроверитьРавенство(ТЗ.Получить(4, "к1"), 10);
	Сам.ПроверитьРавенство(ТЗ.Получить(5, "к1"), 5);
	Сам.ПроверитьРавенство(ТЗ.Получить(6, "к1"), 6);

	Сам.ПроверитьРавенство(ТЗ.КоличествоСтрок("и1"), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура _ЗаполнитьКолонкуОшибка(Парам) Экспорт
	ТЗ = Парам.ПолучитьЗначение(1);
	Индекс = Парам.ПолучитьЗначение(2);
	Колонка = Парам.ПолучитьЗначение(2);
	Значение = Парам.ПолучитьЗначение(2);
	ТЗ.ЗаполнитьКолонку(Индекс, Колонка, Значение);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестЗаполнитьКолонкуОшибка() Экспорт
	Сам = Сам();

	ТЗ = СоздатьОбъект("ИндексированнаяТаблица");
	ТЗ.НоваяКолонка("к1");
	ТЗ.НоваяКолонка("к2");
	ТЗ.НоваяКолонка("к3");

	Для н = 1 По 6 Цикл
		ТЗ.НоваяСтрока();
		ТЗ.к1 = н;
		ТЗ.к2 = 0;
		ТЗ.к3 = 0;
	КонецЦикла;


	Сп = СоздатьОбъект("СписокЗначений");
	Сп.Установить("ТЗ", ТЗ);
	Сп.Установить("Индекс", "и1");
	Сп.Установить("Колонка", "к5");
	Сп.Установить("Значение", 1);

	Сам.ПроверитьИсключение(Сам, "_ЗаполнитьКолонкуОшибка", Сп);

	Сп.Установить("Индекс", "и2");
	Сп.Установить("Колонка", "к1");
	Сам.ПроверитьИсключение(Сам, "_ЗаполнитьКолонкуОшибка", Сп);

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

//_____________________________________________________________________________
Процедура тестУстановитьЗначение() Экспорт
	Сам = Сам();
	ТЗ = ТЗ();

	ТЗ.НоваяКолонка("к1");
	ТЗ.НоваяСтрока();
	ТЗ.УстановитьЗначение(1, 1, 123);
	Сам().ПроверитьРавенство(ТЗ.к1, 123);

	ТЗ.НоваяСтрока();
	ТЗ.УстановитьЗначение(2, 1, 50);
	Сам().ПроверитьРавенство(ТЗ.к1, 50);

	ТЗ.УстановитьЗначение(1, 1, 30);
	Сам().ПроверитьРавенство(ТЗ.Получить(1, 1), 30);

	ТЗ.УстановитьЗначение(1, "к1", 60);
	Сам().ПроверитьРавенство(ТЗ.ПолучитьЗначение(1, 1), 60);

	ТЗ.Установить(1, "к1", 70);
	Сам().ПроверитьРавенство(ТЗ.Получить(1, 1), 70);
КонецПроцедуры

//_____________________________________________________________________________
Процедура _ПолучитьЗначение(Сп) Экспорт
	ТЗ = ТЗ();
	ТЗ.Получить(Сп.ПолучитьЗначение(1), Сп.ПолучитьЗначение(2));
КонецПроцедуры
//_____________________________________________________________________________
Процедура _НетТакойКолонки(парам) Экспорт
	ТЗ = ТЗ();
	з = ТЗ.НетТакойКолонки;
КонецПроцедуры
//_____________________________________________________________________________
Процедура тестПолучитьЗначение() Экспорт
	Сам = Сам();
	ТЗ = ТЗ();

	ТЗ.НоваяКолонка("к1");
	ТЗ.НоваяСтрока();
	ТЗ.Установить(1, 1, 123);

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

	ТЗ.к1 = 333;
	Сам.ПроверитьРавенство(ТЗ.к1, 333);
	ТЗ.НоваяСтрока();
	Сам.ПроверитьРавенство(ТЗ.к1, ПолучитьПустоеЗначение());
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестПолучитьЗначение_Ошибка() Экспорт
	Сам = Сам();
	ТЗ = ТЗ();

	ТЗ.НоваяКолонка("к1");
	ТЗ.НоваяСтрока();

	Сам.ПроверитьИсключение(Сам, "_ПолучитьЗначение", сз(0, 1));
	Сам.ПроверитьИсключение(Сам, "_ПолучитьЗначение", сз(1, 0));
	Сам.ПроверитьИсключение(Сам, "_ПолучитьЗначение", сз(2, 1));
	Сам.ПроверитьИсключение(Сам, "_ПолучитьЗначение", сз(1, 2));
	Сам.ПроверитьИсключение(Сам, "_ПолучитьЗначение", сз(2, 2));

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


//_____________________________________________________________________________
Процедура __тестВыборкаВперед(ИмяИндекса)
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();

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

	Сам.ПроверитьРавенство(ТЗ.ВыбратьСтроки(ИмяИндекса), 1);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(ИмяИндекса), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 1);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 5);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(ИмяИндекса), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 5);
	Сам.ПроверитьРавенство(ТЗ.к2, 1);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 1);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(ИмяИндекса), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 5);
	Сам.ПроверитьРавенство(ТЗ.к2, 2);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 3);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(ИмяИндекса), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 10);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 4);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(ИмяИндекса), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 15);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 2);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(ИмяИндекса), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестВыборкаВперед() Экспорт
	__тестВыборкаВперед("");
	__тестВыборкаВперед(ПолучитьПустоеЗначение());
	__тестВыборкаВперед("Индекс1");
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестВыборка_ПолучитьБезВыбрать() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();
	
	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(), 0);
	Сам.ПроверитьРавенство(ТЗ.СледующаяСтрока(), 0);
	Сам.ПроверитьРавенство(ТЗ.ПредыдущаяСтрока(), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестСортировкаПоУбыванию() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();
	ТЗ.Сортировать("-к1");

	Сам.ПроверитьРавенство(ТЗ.ВыбратьСтроки(), 1);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 15);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 2);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 10);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 4);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 5);
	Сам.ПроверитьРавенство(ТЗ.к2, 1);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 1);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 5);
	Сам.ПроверитьРавенство(ТЗ.к2, 2);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 3);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 1);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 5);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестСортировкаСОбрезаниемПробелов() Экспорт
	Сам = Сам();
	ТЗ = СоздатьОбъект("ИндексированнаяТаблица");
	ТЗ.НоваяКолонка("к1");

	ТЗ.НоваяСтрока(); ТЗ.К1 = "222";
	ТЗ.НоваяСтрока(); ТЗ.К1 = "  111  ";
	ТЗ.НоваяСтрока(); ТЗ.К1 = "111";
	ТЗ.НоваяСтрока(); ТЗ.К1 = "  222  ";
	ТЗ.НоваяСтрока(); ТЗ.К1 = " 111";

	ТЗ.Сортировать("к1#");
	ТЗ.ВыбратьСтроки();

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, "  111  ");

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, "111");

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, " 111");

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, "222");

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, "  222  ");
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестСортировкаБезУчетаРегистра() Экспорт
	Сам = Сам();
	ТЗ = СоздатьОбъект("ИндексированнаяТаблица");
	ТЗ.НоваяКолонка("к1");

	ТЗ.НоваяСтрока(); ТЗ.К1 = "один";
	ТЗ.НоваяСтрока(); ТЗ.К1 = "Один";
	ТЗ.НоваяСтрока(); ТЗ.К1 = "ОдиН";
	ТЗ.НоваяСтрока(); ТЗ.К1 = "два";
	ТЗ.НоваяСтрока(); ТЗ.К1 = "Два";

	ТЗ.Сортировать("^к1");
	ТЗ.ВыбратьСтроки();

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, "два");

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, "Два");

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, "один");

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, "Один");

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, "ОдиН");
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестСортировкаБезУчетаРегистраСОбрезаниемПробелов() Экспорт
	Сам = Сам();
	ТЗ = СоздатьОбъект("ИндексированнаяТаблица");
	ТЗ.НоваяКолонка("к1");

	ТЗ.НоваяСтрока(); ТЗ.К1 = "  один";
	ТЗ.НоваяСтрока(); ТЗ.К1 = "Один  ";
	ТЗ.НоваяСтрока(); ТЗ.К1 = "   ОдиН     ";
	ТЗ.НоваяСтрока(); ТЗ.К1 = "  два	";
	ТЗ.НоваяСтрока(); ТЗ.К1 = "		Два ";

	ТЗ.Сортировать("^к1#");
	ТЗ.ВыбратьСтроки();

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, "  два	");

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, "		Два ");

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, "  один");

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, "Один  ");

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, "   ОдиН     ");
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестВыборкаНазад() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();
	ТЗ.Сортировать("к1");

	Сам.ПроверитьРавенство(ТЗ.ВКонец(), 1);

	Сам.ПроверитьРавенство(ТЗ.ПредыдущаяСтрока(), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 15);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 2);

	Сам.ПроверитьРавенство(ТЗ.ПредыдущаяСтрока(), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 10);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 4);

	Сам.ПроверитьРавенство(ТЗ.ПредыдущаяСтрока(), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 5);
	Сам.ПроверитьРавенство(ТЗ.к2, 2);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 3);

	Сам.ПроверитьРавенство(ТЗ.ПредыдущаяСтрока(), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 5);
	Сам.ПроверитьРавенство(ТЗ.к2, 1);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 1);

	Сам.ПроверитьРавенство(ТЗ.ПредыдущаяСтрока(), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 1);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 5);

	Сам.ПроверитьРавенство(ТЗ.ПредыдущаяСтрока(), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестВыборкаВпередНазад() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();
	ТЗ.Сортировать("к1");

	Сам.ПроверитьРавенство(ТЗ.ВыбратьСтроки(), 1);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 1);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 5);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 5);
	Сам.ПроверитьРавенство(ТЗ.к2, 1);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 1);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 5);
	Сам.ПроверитьРавенство(ТЗ.к2, 2);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 3);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 10);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 4);

	//Назад
	Сам.ПроверитьРавенство(ТЗ.ПредыдущаяСтрока(), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 5);
	Сам.ПроверитьРавенство(ТЗ.к2, 2);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 3);

	Сам.ПроверитьРавенство(ТЗ.ПредыдущаяСтрока(), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 5);
	Сам.ПроверитьРавенство(ТЗ.к2, 1);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 1);

	Сам.ПроверитьРавенство(ТЗ.ПредыдущаяСтрока(), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 1);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 5);

	//и снова вперед
	Сам.ПроверитьРавенство(ТЗ.СледующаяСтрока(), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 5);
	Сам.ПроверитьРавенство(ТЗ.к2, 1);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 1);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестВыборка_ПустаяТаблица() Экспорт
	Сам = Сам();
	ТЗ = СоздатьОбъект("ИндексированнаяТаблица");
	ТЗ.НоваяКолонка("к1");
	ТЗ.ДобавитьИндекс("к1", "к1");

	Сам.ПроверитьРавенство(ТЗ.ВНачало("к1"), 0);
	Сам.ПроверитьРавенство(ТЗ.СледующаяСтрока("к1"), 0);

	Сам.ПроверитьРавенство(ТЗ.ВКонец("к1"), 0);
	Сам.ПроверитьРавенство(ТЗ.ПредыдущаяСтрока("к1"), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестИндексУникален() Экспорт
	Сам = Сам();
	ТЗ = СоздатьОбъект("ИндексированнаяТаблица");
	ТЗ.НоваяКолонка("к1");
	ТЗ.НоваяСтрока(); ТЗ.к1 = 1;
	ТЗ.НоваяСтрока(); ТЗ.к1 = 2;
	ТЗ.НоваяСтрока(); ТЗ.к1 = 3;
	ТЗ.Сортировать("к1");

	Сам.ПроверитьРавенство(ТЗ.ИндексУникален(), 1);

	ТЗ.НоваяСтрока(); ТЗ.к1 = 1;
	Сам.ПроверитьРавенство(ТЗ.ИндексУникален(), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестКоличествоУникальныхКлючей() Экспорт
	Сам = Сам();
	ТЗ = СоздатьОбъект("ИндексированнаяТаблица");
	ТЗ.НоваяКолонка("к1");
	ТЗ.НоваяСтрока(); ТЗ.к1 = 1;
	ТЗ.НоваяСтрока(); ТЗ.к1 = 2;
	ТЗ.НоваяСтрока(); ТЗ.к1 = 3;
	ТЗ.Сортировать("к1");

	Сам.ПроверитьРавенство(ТЗ.КоличествоУникальныхКлючей(), 3);

	ТЗ.НоваяСтрока(); ТЗ.к1 = 1;
	//ТЗ.Сортировать("к1");
	Сам.ПроверитьРавенство(ТЗ.КоличествоУникальныхКлючей(), 2);

	ТЗ.НоваяСтрока(); ТЗ.к1 = 3;
	//ТЗ.Сортировать("к1");
	Сам.ПроверитьРавенство(ТЗ.КоличествоУникальныхКлючей(), 1);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестКоличествоЗначений() Экспорт
	Сам = Сам();
	ТЗ = СоздатьОбъект("ИндексированнаяТаблица");
	ТЗ.НоваяКолонка("к1");
	ТЗ.НоваяСтрока(); ТЗ.к1 = 1;
	ТЗ.НоваяСтрока(); ТЗ.к1 = 2;
	ТЗ.НоваяСтрока(); ТЗ.к1 = 3;
	ТЗ.Сортировать("к1");

	Сам.ПроверитьРавенство(ТЗ.КоличествоЗначенийКлюча(, 1), 1);

	ТЗ.НоваяСтрока(); ТЗ.к1 = 1;
	Сам.ПроверитьРавенство(ТЗ.КоличествоЗначенийКлюча(, 1), 2);

	ТЗ.НоваяСтрока(); ТЗ.к1 = 1;
	Сам.ПроверитьРавенство(ТЗ.КоличествоЗначенийКлюча(, 1), 3);

	ТЗ.НоваяСтрока(); ТЗ.к1 = 3;
	Сам.ПроверитьРавенство(ТЗ.КоличествоЗначенийКлюча(, 3), 2);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестСортировкаУник() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ_Док();
	ТЗ.ДобавитьИндекс("Индекс1", "Док", 1);

	//_РедакторТЗ(ТЗ, "Индекс1");

	ТЗ.ВыбратьСтроки("Индекс1");

	ТЗ.СледующаяСтрока("Индекс1");
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 3);

	ТЗ.СледующаяСтрока("Индекс1");
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 5);

	ТЗ.СледующаяСтрока("Индекс1");
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 1);

	ТЗ.СледующаяСтрока("Индекс1");
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 2);

	Сам.ПроверитьРавенство(ТЗ.СледующаяСтрока("Индекс1"), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестСортировкаДок() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ_Док();
	ТЗ.ДобавитьИндекс("Док", "Док");
	ТЗ.ВыбратьСтроки("Док");
	
	ТЗ.СледующаяСтрока("Док");
	Сам.ПроверитьРавенство(Число(ТЗ.Док.НомерДок), 9);
	ТЗ.СледующаяСтрока("Док");
	Сам.ПроверитьРавенство(Число(ТЗ.Док.НомерДок), 9);

	ТЗ.СледующаяСтрока("Док");
	Сам.ПроверитьРавенство(Число(ТЗ.Док.НомерДок), 1);
	ТЗ.СледующаяСтрока("Док");
	Сам.ПроверитьРавенство(Число(ТЗ.Док.НомерДок), 1);

	ТЗ.СледующаяСтрока("Док");
	Сам.ПроверитьРавенство(Число(ТЗ.Док.НомерДок), 4);

	ТЗ.СледующаяСтрока("Док");
	Сам.ПроверитьРавенство(Число(ТЗ.Док.НомерДок), 3);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестСортировкаСпр() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ_Спр();
	ТЗ.Сортировать("Спр");

	//_РедакторТЗ(ТЗ);

	ТЗ.ВыбратьСтроки();

	ТЗ.СледующаяСтрока();
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 2);

	ТЗ.СледующаяСтрока();
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 1);

	ТЗ.СледующаяСтрока();
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 4);

	ТЗ.СледующаяСтрока();
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 3);

	ТЗ.СледующаяСтрока();
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 5);

	Сам.ПроверитьРавенство(ТЗ.СледующаяСтрока(), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестСортировкаПустоеЗначение() Экспорт
	Сам = Сам();

	ТЗ = СоздатьОбъект("ИндексированнаяТаблица");
	ТЗ.НоваяКолонка("к1");
	ТЗ.НоваяСтрока();
	ТЗ.НоваяСтрока();
	//ТЗ.ЗаполнитьКолонку(, "К1", ПолучитьПустоеЗначение("Справочник.Номенклатура"));
	ТЗ.ДобавитьИндекс("и1", "к1");

	Сам.ПроверитьРавенство(ТЗ.ВКонец(), 1);
	Сам.ПроверитьРавенство(ТЗ.ПредыдущаяСтрока(), 1);
	Сам.ПроверитьРавенство(ТЗ.ПредыдущаяСтрока(), 1);
	Сам.ПроверитьРавенство(ТЗ.ПредыдущаяСтрока(), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестСортировкаПоВнутрПредставлению() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ_Спр();
	ТЗ.НоваяСтрока(); ТЗ.Спр = Перечисление.Новый1.новый2;
	ТЗ.НоваяСтрока(); ТЗ.Спр = Перечисление.Новый1.новый1;
	ТЗ.Сортировать("Спр*");

	//_РедакторТЗ(ТЗ);

	ТЗ.ВыбратьСтроки();

	ТЗ.СледующаяСтрока();
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 7);

	ТЗ.СледующаяСтрока();
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 6);

	ТЗ.СледующаяСтрока();
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 1);

	ТЗ.СледующаяСтрока();
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 2);

	ТЗ.СледующаяСтрока();
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 3);

	ТЗ.СледующаяСтрока();
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 4);

	ТЗ.СледующаяСтрока();
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 5);

	Сам.ПроверитьРавенство(ТЗ.СледующаяСтрока(), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестДобавлениеИндекса() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();

	Сам.ПроверитьРавенство(ТЗ.ДобавитьИндекс("Индекс1", "к1"), 2);
	Сам.ПроверитьРавенство(ТЗ.ДобавитьИндекс("Индекс2", "к1, к2"), 3);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестУдалениеИндекса() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();

	ТЗ.ДобавитьИндекс("Индекс1", "к1");
	ТЗ.ДобавитьИндекс("Индекс2", "к2");
	ТЗ.ДобавитьИндекс("Индекс3", "к2");
	ТЗ.УдалитьИндекс("Индекс1");
	ТЗ.УдалитьИндекс("Индекс2");
	ТЗ.УдалитьИндекс("Индекс3");

	н = ТЗ.ДобавитьИндекс("Индекс2", "к1");
	Сам.ПроверитьРавенство(н, 2);
	ТЗ.УдалитьИндекс(2);
КонецПроцедуры

Процедура тестУдалениеИндекса2() Экспорт
	Сам = Сам();
	ТЗ = СоздатьОбъект("IndexedTable");
	ТЗ.НоваяКолонка("1");
	ТЗ.НоваяКолонка("2");
	ТЗ.НоваяКолонка("3");
	ТЗ.ДобавитьИндекс("1", "1");
	ТЗ.ДобавитьИндекс("2", "2");
	ТЗ.ДобавитьИндекс("3", "3");

	// первая проблема. строковые названия индексов, преобразуемые в числа
	ТЗ.УдалитьИндекс("1");
	ТЗ.УдалитьИндекс("2");
	ТЗ.УдалитьИндекс("3"); // исключение, индекс с именем 3 не найден

	ТЗ.ДобавитьИндекс("1", "1");
	ТЗ.ДобавитьИндекс("2", "2");
	ТЗ.ДобавитьИндекс("3", "3");
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестУдалениеИндексаОшибка() Экспорт
	Сам = Сам();
	ТЗ = СоздатьОбъект("IndexedTable");
	ТЗ.НоваяКолонка("1");
	ТЗ.НоваяКолонка("2");
	ТЗ.НоваяКолонка("3");

	// вторая проблема. некорректное удаление индексов роняет систему
	Сам.ПроверитьИсключение(ТЗ, "УдалитьИндекс", -1);
	Сам.ПроверитьИсключение(ТЗ, "УдалитьИндекс", 0);
	Сам.ПроверитьИсключение(ТЗ, "УдалитьИндекс", 4);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестСортировка_Ошибка() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();

	Сам.ПроверитьИсключение(ТЗ, "Сортировать", 1);
	Сам.ПроверитьИсключение(ТЗ, "Сортировать", "к3");

	Сам.ПроверитьИсключение(ТЗ, "УдалитьИндекс", "");
	Сам.ПроверитьИсключение(ТЗ, "УдалитьИндекс", "к3");
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестИзменениеЗначения() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();

	ТЗ.Сортировать("к1");
	ТЗ.УстановитьЗначение(5, 1, 6);
	//ВывестиТЗ(ТЗ);
	ТЗ.ВНачало();
	ТЗ.СледующаяСтрока();
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 1);
	ТЗ.СледующаяСтрока();
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 3);
	ТЗ.СледующаяСтрока();
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 5);
	Сам.ПроверитьРавенство(ТЗ.к1, 6);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестВыборкаВпередБезИндекса() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();

	Сам.ПроверитьРавенство(ТЗ.ВыбратьСтроки(), 1);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 5);
	Сам.ПроверитьРавенство(ТЗ.к2, 1);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 1);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 15);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 2);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 5);
	Сам.ПроверитьРавенство(ТЗ.к2, 2);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 3);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 10);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 4);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 1);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 5);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестВыборкаНазадБезИндекса() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();

	Сам.ПроверитьРавенство(ТЗ.ВКонец(), 1);


	Сам.ПроверитьРавенство(ТЗ.ПредыдущаяСтрока(), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 1);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 5);

	Сам.ПроверитьРавенство(ТЗ.ПредыдущаяСтрока(), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 10);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 4);

	Сам.ПроверитьРавенство(ТЗ.ПредыдущаяСтрока(), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 5);
	Сам.ПроверитьРавенство(ТЗ.к2, 2);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 3);

	Сам.ПроверитьРавенство(ТЗ.ПредыдущаяСтрока(), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 15);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 2);

	Сам.ПроверитьРавенство(ТЗ.ПредыдущаяСтрока(), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 5);
	Сам.ПроверитьРавенство(ТЗ.к2, 1);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 1);

	Сам.ПроверитьРавенство(ТЗ.ПредыдущаяСтрока(), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестПоиск() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();
	ТЗ.Сортировать("к1");
	сзКлюч = СоздатьОбъект("СписокЗначений");
	сзКлюч.ДобавитьЗначение(0);

	сзКлюч.УстановитьЗначение(1, 5);
	Сам.ПроверитьРавенство(ТЗ.НайтиСтроку(, сзКлюч, 0, 1), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 5);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 1);

	сзКлюч.УстановитьЗначение(1, 15);
	Сам.ПроверитьРавенство(ТЗ.НайтиСтроку(, сзКлюч, 0, 1), 2);
	Сам.ПроверитьРавенство(ТЗ.к1, 15);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 2);

	сзКлюч.УстановитьЗначение(1, 5);
	Сам.ПроверитьРавенство(ТЗ.НайтиСтроку(, сзКлюч, 1, 1), 3);
	Сам.ПроверитьРавенство(ТЗ.к1, 5);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 3);

	сзКлюч.УстановитьЗначение(1, 10);
	Сам.ПроверитьРавенство(ТЗ.НайтиСтроку(, сзКлюч, 0, 1), 4);
	Сам.ПроверитьРавенство(ТЗ.к1, 10);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 4);

	сзКлюч.УстановитьЗначение(1, 1);
	Сам.ПроверитьРавенство(ТЗ.НайтиСтроку(, сзКлюч, 0, 1), 5);
	Сам.ПроверитьРавенство(ТЗ.к1, 1);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 5);

	сзКлюч.УстановитьЗначение(1, 100);
	Сам.ПроверитьРавенство(ТЗ.НайтиСтроку(, сзКлюч, 0, 1), 0);


	сзКлюч.УстановитьЗначение(1, 10);
	Сам.ПроверитьРавенство(ТЗ.НайтиСтроку(, сзКлюч, 0, 1), 4);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 4);

	сзКлюч.УстановитьЗначение(1, 5);
	Сам.ПроверитьРавенство(ТЗ.НайтиСтроку(, сзКлюч, 0, 0), 1);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 4);
	Сам.ПроверитьРавенство(ТЗ.к1, 10);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестПоискОдноЗначение() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();
	ТЗ.Сортировать("к1");

	Сам.ПроверитьРавенство(ТЗ.НайтиСтроку(, 5, 0, 1), 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 5);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 1);

	Сам.ПроверитьРавенство(ТЗ.НайтиСтроку(, 15, 0, 1), 2);
	Сам.ПроверитьРавенство(ТЗ.к1, 15);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 2);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестПоискБезПерепозиционирования() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();
	ТЗ.Сортировать("к1");

	Сам.ПроверитьРавенство(ТЗ.НайтиСтроку(, 5, 0, 1), 1);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 1);
	Сам.ПроверитьРавенство(ТЗ.к1, 5);

	Сам.ПроверитьРавенство(ТЗ.НайтиСтроку(, 15, 0, 0), 2);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 1);

	Сам.ПроверитьРавенство(ТЗ.НайтиСтроку(, 15, 0, 0), 2);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 1);

	ТЗ.ДобавитьИндекс("и1", "к1");
	Сам.ПроверитьРавенство(ТЗ.НайтиСтроку(, 10), 4);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 1);

	Сам.ПроверитьРавенство(ТЗ.НайтиБлижайшуюБольше(9, "и1"), 4);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 1);

	Сам.ПроверитьРавенство(ТЗ.НайтиБлижайшуюМеньше(11, "и1"), 4);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 1);
КонецПроцедуры

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

	//----------------------------------------------------------------
	сзКлюч.УстановитьЗначение(1, 0.1);
	Сам.ПроверитьРавенство(ТЗ.НайтиБлижайшуюБольше(сзКлюч, 1), 5);

	сзКлюч.УстановитьЗначение(1, 5);
	Сам.ПроверитьРавенство(ТЗ.НайтиБлижайшуюБольше(сзКлюч, 1), 1);

	сзКлюч.УстановитьЗначение(1, 4);
	Сам.ПроверитьРавенство(ТЗ.НайтиБлижайшуюБольше(сзКлюч, 1), 1);

	сзКлюч.УстановитьЗначение(1, 11);
	Сам.ПроверитьРавенство(ТЗ.НайтиБлижайшуюБольше(сзКлюч, 1), 2);

	сзКлюч.УстановитьЗначение(1, 100);
	Сам.ПроверитьРавенство(ТЗ.НайтиБлижайшуюБольше(сзКлюч, 1), 0);

	//----------------------------------------------------------------
	сзКлюч.УстановитьЗначение(1, 100);
	Сам.ПроверитьРавенство(ТЗ.НайтиБлижайшуюМеньше(сзКлюч, 1), 2);

	сзКлюч.УстановитьЗначение(1, 11);
	Сам.ПроверитьРавенство(ТЗ.НайтиБлижайшуюМеньше(сзКлюч, 1), 4);

	сзКлюч.УстановитьЗначение(1, 8);
	Сам.ПроверитьРавенство(ТЗ.НайтиБлижайшуюМеньше(сзКлюч, 1), 3);

	сзКлюч.УстановитьЗначение(1, 1);
	Сам.ПроверитьРавенство(ТЗ.НайтиБлижайшуюМеньше(сзКлюч, 1), 5);

	сзКлюч.УстановитьЗначение(1, 0.1);
	Сам.ПроверитьРавенство(ТЗ.НайтиБлижайшуюМеньше(сзКлюч, 1), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестНайтиБлижайшую_Строки() Экспорт
	Сам = Сам();
	ИТ = СоздатьОбъект("ИндексированнаяТаблица");
	ИТ.НоваяКолонка("к1");
	
	ИТ.НоваяСтрока();
	ИТ.к1 = "Иванов";
	ИТ.НоваяСтрока();
	ИТ.к1 = "Патрушев";
	ИТ.НоваяСтрока();
	ИТ.к1 = "Петров";
	ИТ.НоваяСтрока();
	ИТ.к1 = "Сидоров";
	
	ИТ.ДобавитьИндекс("и1", "к1");
	Сам.ПроверитьРавенство(ИТ.НайтиБлижайшуюБольше("Пе", "и1"), 3);
	Сам.ПроверитьРавенство(ИТ.НайтиБлижайшуюБольше("пе", "и1"), 4);

	ИТ.ДобавитьИндекс("и2", "^к1");
	Сам.ПроверитьРавенство(ИТ.НайтиБлижайшуюБольше("ПЕ", "и2"), 3);
	Сам.ПроверитьРавенство(ИТ.НайтиБлижайшуюБольше("пе", "и2"), 3);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестПоискВПустойТаблице() Экспорт
	Сам = Сам();
	ТЗ = ТЗ();
	ТЗ.НоваяКолонка("к1");
	ТЗ.ДобавитьИндекс("и1", "к1");

	Сам.ПроверитьРавенство(ТЗ.НайтиСтроку("и1", 100, 0, 0), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура ПроверкаПоиск_Ошибка_Найти(Сп) Экспорт
	ТЗ = Сп.ПолучитьЗначение(1);
	Индекс = Сп.ПолучитьЗначение(2);
	сзКлюч = Сп.ПолучитьЗначение(3);
	ТЗ.НайтиСтроку(Индекс, сзКлюч);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестПоиск_Ошибка() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();
	ТЗ.Сортировать("к1");

	сзКлюч = СоздатьОбъект("СписокЗначений");

	//в сз д.б. как минимум 1 значение
	Сам.ПроверитьИсключение(Сам, "ПроверкаПоиск_Ошибка_Найти", сз(ТЗ, "", сзКлюч));

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

//_____________________________________________________________________________
Процедура тестФильтр() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();
	ТЗ.Сортировать("к1");
	сзКлючМин = СоздатьОбъект("СписокЗначений");
	сзКлючМин.ДобавитьЗначение(0);
	сзКлючМакс = СоздатьОбъект("СписокЗначений");
	сзКлючМакс.ДобавитьЗначение(0);

	сзКлючМин.УстановитьЗначение(1, 0);
	сзКлючМакс.УстановитьЗначение(1, 5);
	ТЗ.УстановитьФильтр(сзКлючМин, сзКлючМакс);
	//ВывестиТЗ(ТЗ);
	ТЗ.ВыбратьСтроки();
	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 5);
	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 1);
	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 3);
	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(), 0);


	ТЗ.ДобавитьИндекс("Индекс1", "к1");
	сзКлючМин.УстановитьЗначение(1, 4);
	сзКлючМакс.УстановитьЗначение(1, 20);
	ТЗ.УстановитьФильтр(сзКлючМин, сзКлючМакс, "Индекс1");
	ТЗ.ВыбратьСтроки("Индекс1");
	ТЗ.ПолучитьСтроку("Индекс1");
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 1);
	ТЗ.ПолучитьСтроку("Индекс1");
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 3);
	ТЗ.ПолучитьСтроку("Индекс1");
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 4);
	ТЗ.ПолучитьСтроку("Индекс1");
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 2);
	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку("Индекс1"), 0);

	ТЗ.ВыключитьФильтр("Индекс1");
	Сам.ПроверитьРавенство(ТЗ.Итог("к1", "Индекс1"), 36);
	ТЗ.ВыключитьФильтр();
	Сам.ПроверитьРавенство(ТЗ.Итог("к1"), 36);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестФильтрОдноЗначение() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();
	ТЗ.Сортировать("к1");

	ТЗ.УстановитьФильтр(0, 5);
	//ВывестиТЗ(ТЗ);
	ТЗ.ВыбратьСтроки();
	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 5);
	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 1);
	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 3);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестФильтр2() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();
	ТЗ.Сортировать("к1,к2");

	сзФильтр = СоздатьОбъект("СписокЗначений");
	сзФильтр.Установить("к1", 5);
	ТЗ.Подмножество(сзФильтр, 1);

	//ВывестиТЗ(ТЗ);
	ТЗ.ВыбратьСтроки();

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 5);
	Сам.ПроверитьРавенство(ТЗ.к2, 1);

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 5);
	Сам.ПроверитьРавенство(ТЗ.к2, 2);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестФильтрПоУбыванию() Экспорт
	Сам = Сам();
	ТЗ = ТЗ();

	ТЗ.НоваяКолонка("к1");
	ТЗ.НоваяКолонка("к2");

	ТЗ.НоваяСтрока(); ТЗ.к1 = 1; ТЗ.к2 = 10;
	ТЗ.НоваяСтрока(); ТЗ.к1 = 2; ТЗ.к2 = 20;
	ТЗ.НоваяСтрока(); ТЗ.к1 = 1; ТЗ.к2 = 30;
	ТЗ.НоваяСтрока(); ТЗ.к1 = 3; ТЗ.к2 = 40;
	ТЗ.НоваяСтрока(); ТЗ.к1 = 4; ТЗ.к2 = 50;

	ТЗ.ДобавитьИндекс("и1", "к1, -к2");

	сзМин = СоздатьОбъект("СписокЗначений");
	сзМин.ДобавитьЗначение(2);
	сзМин.ДобавитьЗначение(20);
	сзМакс = СоздатьОбъект("СписокЗначений");
	сзМакс.ДобавитьЗначение(3);
	сзМакс.ДобавитьЗначение(0);

	ТЗ.УстановитьФильтр(сзМин, сзМакс, "и1");

	ТЗ.ВыбратьСтроки("и1");

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

	ТЗ.ПолучитьСтроку("и1");
	Сам.ПроверитьРавенство(ТЗ.к1, 3);
	Сам.ПроверитьРавенство(ТЗ.к2, 40);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку("и1"), 0);


	//Неправильный фильтр
	ТЗ.УстановитьФильтр(сзМакс, сзМин, "и1");
	Сам.ПроверитьРавенство(ТЗ.ВыбратьСтроки("и1"), 0);
	ТЗ.ВыбратьСтроки("и1");
	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку("и1"), 0);

	//added by kms
	ТЗ.ДобавитьИндекс("и2", "-к1");
	ТЗ.УстановитьФильтр(0, 10, "и2");
	_т = СоздатьОбъект("ТаблицаЗначений");

	ТЗ.Выгрузить(_т, "и2");
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестПодмножествоПоУбыванию() Экспорт
	Сам = Сам();
	ТЗ = ТЗ();

	ТЗ.НоваяКолонка("к1");
	ТЗ.НоваяКолонка("к2");

	ТЗ.НоваяСтрока(); ТЗ.к1 = 1; ТЗ.к2 = 10;
	ТЗ.НоваяСтрока(); ТЗ.к1 = 2; ТЗ.к2 = 20;
	ТЗ.НоваяСтрока(); ТЗ.к1 = 1; ТЗ.к2 = 30;

	ТЗ.ДобавитьИндекс("и1", "к1, -к2");
	сзКлюч = СоздатьОбъект("СписокЗначений");
	сзКлюч.ДобавитьЗначение(2);
	ТЗ.Подмножество(сзКлюч, 1, "и1");

	ТЗ.ВыбратьСтроки("и1");

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

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку("и1"), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестПодмножествоПоУбыванию2() Экспорт
	Сам = Сам();
	ТЗ = ТЗ();

	ТЗ.НоваяКолонка("к1");
	ТЗ.НоваяКолонка("к3");
	ТЗ.НоваяКолонка("к2");

	ТЗ.НоваяСтрока(); ТЗ.к1 = 1; ТЗ.к2 = 10;
	ТЗ.НоваяСтрока(); ТЗ.к1 = 2; ТЗ.к2 = 20;
	ТЗ.НоваяСтрока(); ТЗ.к1 = 1; ТЗ.к2 = 30;

	ТЗ.ДобавитьИндекс("и1", "к1, -к2");
	сзКлюч = СоздатьОбъект("СписокЗначений");
	сзКлюч.ДобавитьЗначение(2);
	ТЗ.Подмножество(сзКлюч, 1, "и1");

	ТЗ.ВыбратьСтроки("и1");

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

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку("и1"), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестПодмножествоПоУбыванию3() Экспорт
	Сам = Сам();
	ТЗ = ТЗ();

	ТЗ.НоваяКолонка("к1");
	ТЗ.НоваяКолонка("к2");
	ТЗ.НоваяКолонка("к3");

	ТЗ.НоваяСтрока(); ТЗ.к1 = 1; ТЗ.к2 = 100; ТЗ.к3 = 10;
	ТЗ.НоваяСтрока(); ТЗ.к1 = 2; ТЗ.к2 = 200; ТЗ.к3 = 20;
	ТЗ.НоваяСтрока(); ТЗ.к1 = 1; ТЗ.к2 = 300; ТЗ.к3 = 30;
	ТЗ.НоваяСтрока(); ТЗ.к1 = 4; ТЗ.к2 = 400; ТЗ.к3 = 40;

	ТЗ.ДобавитьИндекс("и1", "к1, -к3");
	сзКлюч = СоздатьОбъект("СписокЗначений");
	сзКлюч.ДобавитьЗначение(2);
	ТЗ.Подмножество(сзКлюч, 1, "и1");

	ТЗ.ВыбратьСтроки("и1");

	ТЗ.ПолучитьСтроку("и1");
	Сам.ПроверитьРавенство(ТЗ.к1, 2);
	Сам.ПроверитьРавенство(ТЗ.к3, 20);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку("и1"), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестФильтрУникальныеЗначения() Экспорт
	Сам = Сам();
	ТЗ = ТЗ();

	ТЗ.НоваяКолонка("к1");
	ТЗ.НоваяКолонка("к2");

	ТЗ.НоваяСтрока(); ТЗ.к1 = 1; ТЗ.к2 = 10;
	ТЗ.НоваяСтрока(); ТЗ.к1 = 2; ТЗ.к2 = 20;
	ТЗ.НоваяСтрока(); ТЗ.к1 = 1; ТЗ.к2 = 30;
	ТЗ.НоваяСтрока(); ТЗ.к1 = 2; ТЗ.к2 = 40;
	ТЗ.НоваяСтрока(); ТЗ.к1 = 300; ТЗ.к2 = 400;
	ТЗ.НоваяСтрока(); ТЗ.к1 = -300; ТЗ.к2 = -400;

	ТЗ.ДобавитьИндекс("и1", "к1");
	ТЗ.УстановитьФильтр(0, 100, "и1", 1);

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

	ТЗ.ВыбратьСтроки("и1");

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

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

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку("и1"), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестИтогПоПустомуФильтру() Экспорт
	//Вот такой код валит 1С
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();

	ТЗ.ДобавитьИндекс("к1", "к1");
	ТЗ.УстановитьФильтр(134, 134, "к1"); // несуществующее значение
	//Предупреждение("1");
	Сам.ПроверитьРавенство(ТЗ.Итог("к2", "к1"), 0); // здесь 1с вылетает :(
	//Предупреждение("2");
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестИнверсныйФильтр_ВыборкаВперед() Экспорт
	Сам = Сам();
	ТЗ = СоздатьОбъект("ИндексированнаяТаблица");
	ТЗ.НоваяКолонка("к1");
	ТЗ.НоваяСтрока(); ТЗ.к1 = 1;
	ТЗ.НоваяСтрока(); ТЗ.к1 = 2;
	ТЗ.НоваяСтрока(); ТЗ.к1 = 3;
	ТЗ.НоваяСтрока(); ТЗ.к1 = 4;
	ТЗ.НоваяСтрока(); ТЗ.к1 = 5;

	ТЗ.ДобавитьИндекс("к1", "к1");
	ТЗ.УстановитьФильтр(2, 4, "к1", 0, 1);

	ТЗ.ВыбратьСтроки("к1");

	ТЗ.ПолучитьСтроку("к1");
	Сам.ПроверитьРавенство(ТЗ.к1, 1);
	ТЗ.ПолучитьСтроку("к1");
	Сам.ПроверитьРавенство(ТЗ.к1, 5);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку("к1"), 0);

	//-------------------------------------------
	ТЗ.УстановитьФильтр(0, 4, "к1", 0, 1);

	ТЗ.ВыбратьСтроки("к1");

	ТЗ.ПолучитьСтроку("к1");
	Сам.ПроверитьРавенство(ТЗ.к1, 5);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку("к1"), 0);
КонецПроцедуры


//_____________________________________________________________________________
Процедура тестИтог() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();

	Сам.ПроверитьРавенство(ТЗ.Итог("к1"), 36);

	ТЗ.Сортировать("к1");
	сзКлючМин = СоздатьОбъект("СписокЗначений");
	сзКлючМин.ДобавитьЗначение(0);
	сзКлючМакс = СоздатьОбъект("СписокЗначений");
	сзКлючМакс.ДобавитьЗначение(0);

	сзКлючМин.УстановитьЗначение(1, 0);
	сзКлючМакс.УстановитьЗначение(1, 5);
	ТЗ.УстановитьФильтр(сзКлючМин, сзКлючМакс);
	Сам.ПроверитьРавенство(ТЗ.Итог(1), 11);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестИтогПоДиапазону() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();

	ТЗ.ДобавитьИндекс("и1", "к1");

	Сам.ПроверитьРавенство(ТЗ.ИтогПоДиапазону("к1", "и1", 0, 5), 11);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестИтогПоУзлу_Выборка() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();

	ТЗ.ДобавитьИндекс("и1", "к1");
	ТЗ.ВыбратьСтроки("и1");
	
	ТЗ.СледующаяСтрока("и1", 1); //к1 == 1
	Сам.ПроверитьРавенство(ТЗ.ИтогПоУзлу("к1", "и1"), 1);

	ТЗ.СледующаяСтрока("и1", 1); //к1 == 5
	Сам.ПроверитьРавенство(ТЗ.ИтогПоУзлу("к1", "и1"), 10);
	Сам.ПроверитьРавенство(ТЗ.ИтогПоУзлу("к2", "и1"), 3);

	ТЗ.СледующаяСтрока("и1", 1); //к1 == 10
	Сам.ПроверитьРавенство(ТЗ.ИтогПоУзлу("к1", "и1"), 10);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестИтогПоУзлу_Поиск() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();

	ТЗ.ДобавитьИндекс("и1", "к1");

	ТЗ.НайтиСтроку("и1", 5, 0, 1);
	Сам.ПроверитьРавенство(ТЗ.ИтогПоУзлу("к2", "и1"), 3);

	ТЗ.НайтиСтроку("и1", 10, 0, 1);
	Сам.ПроверитьРавенство(ТЗ.ИтогПоУзлу("к1", "и1"), 10);
КонецПроцедуры


//_____________________________________________________________________________
Процедура тестСвернуть() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();

	ТЗ.НоваяСтрока();
	ТЗ.к1 = 10;
	ТЗ.НоваяСтрока();
	ТЗ.к1 = 10;
	ТЗ.НоваяСтрока();
	ТЗ.к1 = 1;

	ТЗ.ВыбратьСтроки();
	Пока ТЗ.ПолучитьСтроку() = 1 Цикл
		ТЗ.к2 = ТЗ.к1;
	КонецЦикла;

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

	ТЗ.ВыбратьСтроки();

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 1);
	Сам.ПроверитьРавенство(ТЗ.к2, 2);

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 5);
	Сам.ПроверитьРавенство(ТЗ.к2, 10);

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 10);
	Сам.ПроверитьРавенство(ТЗ.к2, 30);

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 15);
	Сам.ПроверитьРавенство(ТЗ.к2, 15);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестСвернутьПоИндексу() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();

	ТЗ.НоваяСтрока();
	ТЗ.к1 = 10;
	ТЗ.НоваяСтрока();
	ТЗ.к1 = 10;
	ТЗ.НоваяСтрока();
	ТЗ.к1 = 1;

	ТЗ.ВыбратьСтроки();
	Пока ТЗ.ПолучитьСтроку() = 1 Цикл
		ТЗ.к2 = ТЗ.к1;
	КонецЦикла;

	ТЗ.ДобавитьИндекс("Индекс1", "к1");
	ТЗ.Свернуть("к1", "к2", "Индекс1");

	ТЗ.ВыбратьСтроки("Индекс1");

	ТЗ.ПолучитьСтроку("Индекс1");
	Сам.ПроверитьРавенство(ТЗ.к1, 1);
	Сам.ПроверитьРавенство(ТЗ.к2, 2);

	ТЗ.ПолучитьСтроку("Индекс1");
	Сам.ПроверитьРавенство(ТЗ.к1, 5);
	Сам.ПроверитьРавенство(ТЗ.к2, 10);

	ТЗ.ПолучитьСтроку("Индекс1");
	Сам.ПроверитьРавенство(ТЗ.к1, 10);
	Сам.ПроверитьРавенство(ТЗ.к2, 30);

	ТЗ.ПолучитьСтроку("Индекс1");
	Сам.ПроверитьРавенство(ТЗ.к1, 15);
	Сам.ПроверитьРавенство(ТЗ.к2, 15);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестСвернутьСпр() Экспорт
	Сам = Сам();

	ТЗ = ТЗ();
	ТЗ.НоваяКолонка("Спр");
	ТЗ.НоваяКолонка("К1");

	ТЗ.НоваяСтрока();
	ТЗ.Спр = Спр("1 Запись 1", 1);
	Спр = ТЗ.Спр; ТЗ.к1 = 1;

	ТЗ.НоваяСтрока();
	ТЗ.Спр = Спр; ТЗ.к1 = 2;

	ТЗ.НоваяСтрока();
	ТЗ.Спр = Спр("1 Запись 1", 2);  ТЗ.к1 = 4;

	ТЗ.Свернуть("Спр", "К1");

	ТЗ.ВыбратьСтроки();

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 3);

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 4);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(), 0);
КонецПроцедуры


//_____________________________________________________________________________
Процедура тестГруппировать1() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ_Док();
	//_РедакторТЗ(ТЗ);
	ТЗ.Группировать("ДатаДок: ДатаДок; Док: Док", "к1, к2", 1);

	//_РедакторТЗ(ТЗ);

	Сам.ПроверитьРавенство(ТЗ.КоличествоСтрок(), 3);

	Сам.ПроверитьРавенство(ТЗ.Получить(1, "ДатаДок"), '03.01.2005');
	Сам.ПроверитьРавенство(ТЗ.Получить(1, "к1"), 3);

	Сам.ПроверитьРавенство(ТЗ.Получить(2, "ДатаДок"), '01.01.2005');
	Сам.ПроверитьРавенство(ТЗ.Получить(2, "к1"), 7);

	Сам.ПроверитьРавенство(ТЗ.Получить(3, "ДатаДок"), '02.01.2005');
	Сам.ПроверитьРавенство(ТЗ.Получить(3, "к1"), 11);

	тзПотомки = ТЗ.Получить(2, "тзПотомки");
	Сам.ПроверитьРавенство(тзПотомки.КоличествоСтрок(), 1);
	Сам.ПроверитьРавенство(тзПотомки.Получить(1, "к1"), 7);

	тзПотомки = тзПотомки.Получить(1, "тзПотомки");
	Сам.ПроверитьРавенство(тзПотомки.КоличествоСтрок(), 2);
	Сам.ПроверитьРавенство(тзПотомки.Получить(1, "к1"), 3);
	Сам.ПроверитьРавенство(тзПотомки.Получить(2, "к1"), 4);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестГруппировать2() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ_Док();
	ТЗ.Группировать("ДатаДок: ДатаДок; Док: Док", "к1, к2");

	//_РедакторТЗ(ТЗ, "ДатаДок");

	Сам.ПроверитьРавенство(ТЗ.КоличествоСтрок(), 3);

	Сам.ПроверитьРавенство(ТЗ.Получить(1, "ДатаДок"), '03.01.2005');
	Сам.ПроверитьРавенство(ТЗ.Получить(1, "к1"), 3);

	Сам.ПроверитьРавенство(ТЗ.Получить(2, "ДатаДок"), '01.01.2005');
	Сам.ПроверитьРавенство(ТЗ.Получить(2, "к1"), 7);

	Сам.ПроверитьРавенство(ТЗ.Получить(3, "ДатаДок"), '02.01.2005');
	Сам.ПроверитьРавенство(ТЗ.Получить(3, "к1"), 11);

	тзПотомки = ТЗ.Получить(2, "тзПотомки");
	Сам.ПроверитьРавенство(тзПотомки.КоличествоСтрок(), 1);
	Сам.ПроверитьРавенство(тзПотомки.Получить(1, "к1"), 7);

	Сам.ПроверитьРавенство(тзПотомки.НомерКолонки("тзПотомки"), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестГруппироватьПоСправочнику1() Экспорт
	Сам = Сам();
	ТЗ = СоздатьОбъект("ИндексированнаяТаблица");
	ТЗ.НоваяКолонка("Эл");
	ТЗ.НоваяКолонка("Сумма");

	Спр = СоздатьОбъект("Справочник.Новый1");
	Спр.НоваяГруппа();
	Спр.Наименование = "Грп1";
	Спр.Записать();
	Грп1 = Спр.ТекущийЭлемент();

	Спр.НоваяГруппа();
	Спр.Родитель = Грп1;
	Спр.Наименование = "Грп2";
	Спр.Записать();
	Грп2 = Спр.ТекущийЭлемент();

	ТЗ.НоваяСтрока(); ТЗ.Эл = Спр("Эл1", 1);
	ТЗ.НоваяСтрока(); ТЗ.Эл = Спр("Эл2", 2, Грп1);
	ТЗ.НоваяСтрока(); ТЗ.Эл = Спр("Эл3", 3, Грп1);
	ТЗ.НоваяСтрока(); ТЗ.Эл = Спр("Эл4", 4, Грп2);
	ТЗ.НоваяСтрока(); ТЗ.Эл = Спр("Эл5", 5, Грп2);
	ТЗ.ВыбратьСтроки();
	Пока ТЗ.ПолучитьСтроку() = 1 Цикл
		ТЗ.Сумма = 1;
	КонецЦикла;

	ТЗ.Группировать("Эл: &Эл", "Сумма");

	Сам.ПроверитьРавенство(ТЗ.КоличествоСтрок(), 2);

	//_РедакторТЗ(ТЗ, "Эл");

	ТЗ.ВыбратьСтроки("Эл");

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку("Эл"), 1);
	Сам.ПроверитьРавенство(""+ТЗ.Эл, "Грп1");
	Сам.ПроверитьРавенство(ТЗ.Сумма, 4);
	тзГрп1 = ТЗ.тзПотомки;

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку("Эл"), 1);
	Сам.ПроверитьРавенство(""+ТЗ.Эл, "Эл1");
	Сам.ПроверитьРавенство(ТЗ.Сумма, 1);

	//-------------------------------------------------
	тзГрп1.ДобавитьИндекс("Эл", "Эл");
	тзГрп1.ВыбратьСтроки("Эл");

	Сам.ПроверитьРавенство(тзГрп1.ПолучитьСтроку("Эл"), 1);
	Сам.ПроверитьРавенство(""+тзГрп1.Эл, "Грп2");
	Сам.ПроверитьРавенство(тзГрп1.Сумма, 2);
	тзГрп2 = тзГрп1.тзПотомки;

	Сам.ПроверитьРавенство(тзГрп1.ПолучитьСтроку("Эл"), 1);
	Сам.ПроверитьРавенство(""+тзГрп1.Эл, "Эл2");
	Сам.ПроверитьРавенство(тзГрп1.Сумма, 1);

	Сам.ПроверитьРавенство(тзГрп1.ПолучитьСтроку("Эл"), 1);
	Сам.ПроверитьРавенство(""+тзГрп1.Эл, "Эл3");
	Сам.ПроверитьРавенство(тзГрп1.Сумма, 1);

	//-------------------------------------------------
	тзГрп2.ДобавитьИндекс("Эл", "Эл");
	тзГрп2.ВыбратьСтроки("Эл");

	Сам.ПроверитьРавенство(тзГрп2.ПолучитьСтроку("Эл"), 1);
	Сам.ПроверитьРавенство(""+тзГрп2.Эл, "Эл4");
	Сам.ПроверитьРавенство(тзГрп2.Сумма, 1);

	Сам.ПроверитьРавенство(тзГрп2.ПолучитьСтроку("Эл"), 1);
	Сам.ПроверитьРавенство(""+тзГрп2.Эл, "Эл5");
	Сам.ПроверитьРавенство(тзГрп2.Сумма, 1);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестГруппироватьПоСправочнику2() Экспорт
	Сам = Сам();
	ТЗ = СоздатьОбъект("ИндексированнаяТаблица");
	ТЗ.НоваяКолонка("Эл");
	ТЗ.НоваяКолонка("Сумма");

	Спр = СоздатьОбъект("Справочник.Новый1");
	Спр.НоваяГруппа();
	Спр.Наименование = "Грп1";
	Спр.Записать();
	Грп1 = Спр.ТекущийЭлемент();

	Спр.НоваяГруппа();
	Спр.Родитель = Грп1;
	Спр.Наименование = "Грп2";
	Спр.Записать();
	Грп2 = Спр.ТекущийЭлемент();

	ТЗ.НоваяСтрока(); ТЗ.Эл = Спр("Эл1", 1);
	ТЗ.НоваяСтрока(); ТЗ.Эл = Спр("Эл4", 4, Грп2);
	ТЗ.НоваяСтрока(); ТЗ.Эл = Спр("Эл5", 5, Грп2);
	ТЗ.ВыбратьСтроки();
	Пока ТЗ.ПолучитьСтроку() = 1 Цикл
		ТЗ.Сумма = 1;
	КонецЦикла;

	ТЗ.Группировать("Эл: &Эл", "Сумма");
	//_РедакторТЗ(ТЗ, "Эл");

	Сам.ПроверитьРавенство(ТЗ.КоличествоСтрок(), 2);


	ТЗ.ВыбратьСтроки("Эл");

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку("Эл"), 1);
	Сам.ПроверитьРавенство(""+ТЗ.Эл, "Грп1");
	Сам.ПроверитьРавенство(ТЗ.Сумма, 2);
	тзГрп1 = ТЗ.тзПотомки;

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку("Эл"), 1);
	Сам.ПроверитьРавенство(""+ТЗ.Эл, "Эл1");
	Сам.ПроверитьРавенство(ТЗ.Сумма, 1);

	//-------------------------------------------------
	тзГрп1.ДобавитьИндекс("Эл", "Эл");
	тзГрп1.ВыбратьСтроки("Эл");

	Сам.ПроверитьРавенство(тзГрп1.КоличествоСтрок(), 1);

	Сам.ПроверитьРавенство(тзГрп1.ПолучитьСтроку("Эл"), 1);
	Сам.ПроверитьРавенство(""+тзГрп1.Эл, "Грп2");
	Сам.ПроверитьРавенство(тзГрп1.Сумма, 2);
	тзГрп2 = тзГрп1.тзПотомки;

	//-------------------------------------------------
	тзГрп2.ДобавитьИндекс("Эл", "Эл");
	тзГрп2.ВыбратьСтроки("Эл");

	Сам.ПроверитьРавенство(тзГрп2.КоличествоСтрок(), 2);

	Сам.ПроверитьРавенство(тзГрп2.ПолучитьСтроку("Эл"), 1);
	Сам.ПроверитьРавенство(""+тзГрп2.Эл, "Эл4");
	Сам.ПроверитьРавенство(тзГрп2.Сумма, 1);

	Сам.ПроверитьРавенство(тзГрп2.ПолучитьСтроку("Эл"), 1);
	Сам.ПроверитьРавенство(""+тзГрп2.Эл, "Эл5");
	Сам.ПроверитьРавенство(тзГрп2.Сумма, 1);
КонецПроцедуры

Процедура тестГруппироватьПоСправочнику_Уровень() Экспорт
	Сам = Сам();
	ТЗ = СоздатьОбъект("ИндексированнаяТаблица");
	ТЗ.НоваяКолонка("Эл");
	ТЗ.НоваяКолонка("Сумма");

	Спр = СоздатьОбъект("Справочник.Новый1");
	Спр.НоваяГруппа();
	Спр.Наименование = "Грп1";
	Спр.Записать();
	Грп1 = Спр.ТекущийЭлемент();

	Спр.НоваяГруппа();
	Спр.Родитель = Грп1;
	Спр.Наименование = "Грп2";
	Спр.Записать();
	Грп2 = Спр.ТекущийЭлемент();

	ТЗ.НоваяСтрока(); ТЗ.Эл = Спр("Эл1", 1);
	ТЗ.НоваяСтрока(); ТЗ.Эл = Спр("Эл2", 2, Грп1);
	ТЗ.НоваяСтрока(); ТЗ.Эл = Спр("Эл3", 3, Грп1);
	ТЗ.НоваяСтрока(); ТЗ.Эл = Спр("Эл4", 4, Грп2);
	ТЗ.НоваяСтрока(); ТЗ.Эл = Спр("Эл5", 5, Грп2);
	ТЗ.ВыбратьСтроки();
	Пока ТЗ.ПолучитьСтроку() = 1 Цикл
		ТЗ.Сумма = 1;
	КонецЦикла;

	ТЗ.Группировать("Эл: &Эл", "Сумма");

	Сам.ПроверитьРавенство(ТЗ.КоличествоСтрок(), 2);

	//_РедакторТЗ(ТЗ, "Эл");

	ТЗ.ВыбратьСтроки("Эл");

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку("Эл"), 1);
	Сам.ПроверитьРавенство(""+ТЗ.Эл, "Грп1");
	Сам.ПроверитьРавенство(ТЗ.__Уровень__, 1);
	тзГрп1 = ТЗ.тзПотомки;

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку("Эл"), 1);
	Сам.ПроверитьРавенство(""+ТЗ.Эл, "Эл1");
	//Сам.ПроверитьРавенство(ТЗ.__Уровень__, 1);

	//-------------------------------------------------
	тзГрп1.ДобавитьИндекс("Эл", "Эл");
	тзГрп1.ВыбратьСтроки("Эл");

	Сам.ПроверитьРавенство(тзГрп1.ПолучитьСтроку("Эл"), 1);
	Сам.ПроверитьРавенство(""+тзГрп1.Эл, "Грп2");
	Сам.ПроверитьРавенство(тзГрп1.__Уровень__, 2);
	тзГрп2 = тзГрп1.тзПотомки;

	Сам.ПроверитьРавенство(тзГрп1.ПолучитьСтроку("Эл"), 1);
	Сам.ПроверитьРавенство(""+тзГрп1.Эл, "Эл2");
	//Сам.ПроверитьРавенство(тзГрп1.__Уровень__, 2);

	Сам.ПроверитьРавенство(тзГрп1.ПолучитьСтроку("Эл"), 1);
	Сам.ПроверитьРавенство(""+тзГрп1.Эл, "Эл3");
	//Сам.ПроверитьРавенство(тзГрп1.__Уровень__, 2);

	//-------------------------------------------------
	тзГрп2.ДобавитьИндекс("Эл", "Эл");
	тзГрп2.ВыбратьСтроки("Эл");

	Сам.ПроверитьРавенство(тзГрп2.ПолучитьСтроку("Эл"), 1);
	Сам.ПроверитьРавенство(""+тзГрп2.Эл, "Эл4");
	//Сам.ПроверитьРавенство(тзГрп2.__Уровень__, 3);

	Сам.ПроверитьРавенство(тзГрп2.ПолучитьСтроку("Эл"), 1);
	Сам.ПроверитьРавенство(""+тзГрп2.Эл, "Эл5");
	//Сам.ПроверитьРавенство(тзГрп2.__Уровень__, 3);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестГруппироватьПоДате() Экспорт
	Сам = Сам();
	ТЗ = СоздатьОбъект("ИндексированнаяТаблица");

	ТЗ.НоваяКолонка("Дата");
	ТЗ.НоваяКолонка("Сумма");

	ТЗ.НоваяСтрока(); ТЗ.Дата = '10.01.2005'; ТЗ.Сумма = 1;
	ТЗ.НоваяСтрока(); ТЗ.Дата = '20.01.2005'; ТЗ.Сумма = 1;
	ТЗ.НоваяСтрока(); ТЗ.Дата = '10.10.2004'; ТЗ.Сумма = 2;
	ТЗ.НоваяСтрока(); ТЗ.Дата = '11.10.2004'; ТЗ.Сумма = 2;
	ТЗ.НоваяСтрока(); ТЗ.Дата = '20.10.2004'; ТЗ.Сумма = 2;
	ТЗ.НоваяСтрока(); ТЗ.Дата = '10.11.2004'; ТЗ.Сумма = 3;

	ТЗ.Группировать("Дата: &Дата", "Сумма");

	Сам.ПроверитьРавенство(ТЗ.КоличествоСтрок(), 3);


	ТЗ.ВыбратьСтроки("Дата");

	ТЗ.ПолучитьСтроку("Дата");
	Сам.ПроверитьРавенство(ТЗ.Получить(, "Дата"), '01.10.2004');
	Сам.ПроверитьРавенство(ТЗ.Получить(, "Сумма"), 6);

	ТЗ.ПолучитьСтроку("Дата");
	Сам.ПроверитьРавенство(ТЗ.Получить(, "Дата"), '01.11.2004');
	Сам.ПроверитьРавенство(ТЗ.Получить(, "Сумма"), 3);

	ТЗ.ПолучитьСтроку("Дата");
	Сам.ПроверитьРавенство(ТЗ.Получить(, "Дата"), '01.01.2005');
	Сам.ПроверитьРавенство(ТЗ.Получить(, "Сумма"), 2);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестГруппировать_ПустаяТаблица() Экспорт
	ТЗ = СоздатьОбъект("ИндексированнаяТаблица");
	ТЗ.НоваяКолонка("К1");
	ТЗ.НоваяКолонка("Ресурс");

	ТЗ.Группировать("К1: К1", "Ресурс");
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестГруппироватьПоПустомуЗначению() Экспорт
	_ти = СоздатьОбъект("ИндексированнаяТаблица");
	_ти.НоваяКолонка("К1");
	_ти.НоваяКолонка("Ресурс");

	_ти.НоваяСтрока();
	_ти.НоваяСтрока();
	_ти.ЗаполнитьКолонку(, "К1", ПолучитьПустоеЗначение("Справочник.Номенклатура"));
	_ти.ЗаполнитьКолонку(, "Ресурс", 1);

	_ти.Группировать("К1: *&К1", "Ресурс", 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура _ГруппироватьОшибка(Сп) Экспорт
	ТЗ = Сп.Получить("ТЗ");
	ТЗ.Группировать(Сп.Получить("Группировки"), Сп.Получить("КолонкиСумм"));
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестГруппироватьОшибка() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ_Док();

	Сп = СоздатьОбъект("СписокЗначений");
	Сп.Установить("ТЗ", ТЗ);

	Сп.Установить("Группировки", "НетКолонки: НетКолонки");
	Сп.Установить("КолонкиСумм", "к1, к2");
	Сам().ПроверитьИсключение(Сам(), "_ГруппироватьОшибка", Сп);

	Сп.Установить("Группировки", "Док: Док; НетКолонки: НетКолонки");
	Сп.Установить("КолонкиСумм", "к1, к2");
	Сам().ПроверитьИсключение(Сам(), "_ГруппироватьОшибка", Сп);

	Сп.Установить("Группировки", "Док: Док");
	Сп.Установить("КолонкиСумм", "НетКолонки, к2");
	Сам().ПроверитьИсключение(Сам(), "_ГруппироватьОшибка", Сп);

	Сп.Установить("Группировки", "Док: Док");
	Сп.Установить("КолонкиСумм", "к1, НетКолонки");
	Сам().ПроверитьИсключение(Сам(), "_ГруппироватьОшибка", Сп);
КонецПроцедуры


//_____________________________________________________________________________
Процедура тестСвернутьДок() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ_Док();

	ТЗ.ДобавитьИндекс("Индекс1", "Док");
	ТЗ.Свернуть(, "к1, к2", "Индекс1");

	//_РедакторТЗ(ТЗ, "Индекс1");

	ТЗ.ВыбратьСтроки("Индекс1");

	ТЗ.ПолучитьСтроку("Индекс1");
	Сам.ПроверитьРавенство(СокрЛП(ТЗ.Док.НомерДок), "9");
	Сам.ПроверитьРавенство(ТЗ.к1, 7);
	Сам.ПроверитьРавенство(ТЗ.к2, 14);

	ТЗ.ПолучитьСтроку("Индекс1");
	Сам.ПроверитьРавенство(СокрЛП(ТЗ.Док.НомерДок), "1");
	Сам.ПроверитьРавенство(ТЗ.к1, 11);
	Сам.ПроверитьРавенство(ТЗ.к2, 22);

	ТЗ.ПолучитьСтроку("Индекс1");
	Сам.ПроверитьРавенство(СокрЛП(ТЗ.Док.НомерДок), "4");
	Сам.ПроверитьРавенство(ТЗ.к1, 1);
	Сам.ПроверитьРавенство(ТЗ.к2, 2);

	ТЗ.ПолучитьСтроку("Индекс1");
	Сам.ПроверитьРавенство(СокрЛП(ТЗ.Док.НомерДок), "3");
	Сам.ПроверитьРавенство(ТЗ.к1, 2);
	Сам.ПроверитьРавенство(ТЗ.к2, 4);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку("Индекс1"), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестОчистить() Экспорт
	ТЗ = ТЗ();
	Сам = Сам();

	ТЗ.НоваяКолонка("К1");
	ТЗ.НоваяКолонка("К2");
	ТЗ.НоваяСтрока();
	ТЗ.к1 = 1;
	ТЗ.НоваяСтрока();
	ТЗ.к2 = 2;

	Сам.ПроверитьРавенство(ТЗ.КоличествоКолонок(), 2);
	Сам.ПроверитьРавенство(ТЗ.КоличествоСтрок(), 2);

	ТЗ.Очистить();
	Сам.ПроверитьРавенство(ТЗ.КоличествоКолонок(), 0);
	Сам.ПроверитьРавенство(ТЗ.КоличествоСтрок(), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестУдалитьСтроку() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();

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

	ТЗ.УдалитьСтроку(3);
	//ВывестиТЗ(ТЗ);

	ТЗ.ВыбратьСтроки();

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 1);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 4);

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 5);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 1);

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 10);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 3);

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 15);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 2);

	//==========================
	ТЗ.УдалитьСтроку(1);
	ТЗ.ВыбратьСтроки();

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 1);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 3);

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 10);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 2);

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 15);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 1);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестУдалитьСтроки() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();

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

	ТЗ.УдалитьСтроки();
	Сам.ПроверитьРавенство(ТЗ.КоличествоСтрок(), 0);
	Сам.ПроверитьРавенство(ТЗ.КоличествоКолонок(), 2);

	ТЗ = Выборка_ЗаполнитьТЗ();
	ТЗ.ДобавитьИндекс("к1", "к1");
	ТЗ.УстановитьФильтр(1, 5, "к1");
	ТЗ.УдалитьСтроки("к1");
	Сам.ПроверитьРавенство(ТЗ.КоличествоСтрок(), 2);

	ТЗ = Выборка_ЗаполнитьТЗ();
	ТЗ.ДобавитьИндекс("к1", "к1");
	ТЗ.УстановитьФильтр(1, 5, "к1", 0, 1);
	ТЗ.УдалитьСтроки("к1");
	Сам.ПроверитьРавенство(ТЗ.КоличествоСтрок(), 3);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестВыгрузить() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();

	ТЗ2 = СоздатьОбъект("ТаблицаЗначений");
	ТЗ.Выгрузить(ТЗ2);

	ТЗ = ТЗ2;

	ТЗ.ВыбратьСтроки();

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 5);
	Сам.ПроверитьРавенство(ТЗ.к2, 1);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 1);

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 15);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 2);

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 5);
	Сам.ПроверитьРавенство(ТЗ.к2, 2);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 3);

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 10);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 4);

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 1);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 5);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестВыгрузитьРасш() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();

	ТЗ2 = СоздатьОбъект("ИндексированнаяТаблица");
	ТЗ.Выгрузить(ТЗ2);

	Сам.ПроверитьРавенство(ТЗ2.Итог("к1"), 36);
	Сам.ПроверитьРавенство(ТЗ2.КоличествоСтрок(), 5);
	Сам.ПроверитьРавенство(ТЗ2.КоличествоКолонок(), 2);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестВыгрузитьСЗ() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();
	ТЗ.Сортировать("к1");

	Сз = СоздатьОбъект("СписокЗначений");
	ТЗ.Выгрузить(Сз,, "к1");

	Сам.ПроверитьРавенство(Сз.ПолучитьЗначение(1), 1);
	Сам.ПроверитьРавенство(Сз.ПолучитьЗначение(2), 5);
	Сам.ПроверитьРавенство(Сз.ПолучитьЗначение(3), 5);
	Сам.ПроверитьРавенство(Сз.ПолучитьЗначение(4), 10);
	Сам.ПроверитьРавенство(Сз.ПолучитьЗначение(5), 15);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестВыгрузитьДок() Экспорт
	Сам = Сам();
	ТЗ = ТЗ();
	ТЗ.НоваяКолонка("Новый1");

	ТЗ.НоваяСтрока();
	ТЗ.Новый1 = "стр 1";
	ТЗ.НоваяСтрока();
	ТЗ.Новый1 = "стр 2";

	Док = СоздатьОбъект("Документ.Новый1");
	Док.Новый();
	ТЗ.Выгрузить(Док);

	Сам.ПроверитьРавенство(Док.КоличествоСтрок(), 2);
	Док.ПолучитьСтрокуПоНомеру(1);
	Сам.ПроверитьРавенство(СокрЛП(Док.новый1), "стр 1");
	Док.ПолучитьСтрокуПоНомеру(2);
	Сам.ПроверитьРавенство(СокрЛП(Док.новый1), "стр 2");
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестВыгрузитьПуст() Экспорт
	Перем ТЗ2;

	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();

	ТЗ.Выгрузить(ТЗ2);

	Сам.ПроверитьРавенство(ТипЗначенияСтр(ТЗ2), "ИндексированнаяТаблица");
	Сам.ПроверитьРавенство(ТЗ2.Итог("к1"), 36);
	Сам.ПроверитьРавенство(ТЗ2.КоличествоСтрок(), 5);
	Сам.ПроверитьРавенство(ТЗ2.КоличествоКолонок(), 2);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестВыгрузитьСФильтром() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();

	ТЗ.ДобавитьИндекс("ДляВыгрузки", "к1");
	сзКлючМин = СоздатьОбъект("СписокЗначений");
	сзКлючМин.ДобавитьЗначение(4);
	сзКлючМакс = СоздатьОбъект("СписокЗначений");
	сзКлючМакс.ДобавитьЗначение(11);
	ТЗ.УстановитьФильтр(сзКлючМин, сзКлючМакс, "ДляВыгрузки");

	ТЗ2 = СоздатьОбъект("ТаблицаЗначений");
	ТЗ.Выгрузить(ТЗ2, "ДляВыгрузки");

	ТЗ = ТЗ2;

	ТЗ.ВыбратьСтроки();

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 5);

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 5);

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 10);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестВыгрузитьСФильтромДок() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ_Док();

	Док1 = ТЗ.ПолучитьЗначение(5, 1);
	Док2 = ТЗ.ПолучитьЗначение(1, 1);

	ТЗ.ДобавитьИндекс("ДляВыгрузки", "Док");

	сзКлючМин = СоздатьОбъект("СписокЗначений");
	сзКлючМин.ДобавитьЗначение(Док1);
	сзКлючМакс = СоздатьОбъект("СписокЗначений");
	сзКлючМакс.ДобавитьЗначение(Док2);
	ТЗ.УстановитьФильтр(сзКлючМин, сзКлючМакс, "ДляВыгрузки");

	ТЗ2 = СоздатьОбъект("ТаблицаЗначений");
	ТЗ.Выгрузить(ТЗ2, "ДляВыгрузки");

	ТЗ = ТЗ2;

	ТЗ.ВыбратьСтроки();

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 5);

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 6);

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 1);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(), 0);
КонецПроцедуры


//_____________________________________________________________________________
Процедура тестЗагрузить() Экспорт
	Сам = Сам();
	ТЗ = СоздатьОбъект("ТаблицаЗначений");
	ТЗ.НоваяКолонка("к1");
	ТЗ.НоваяКолонка("к2");
	ТЗ.НоваяСтрока();
	ТЗ.к1 = 1; ТЗ.к2 = 2;
	ТЗ.НоваяСтрока();
	ТЗ.к1 = 2; ТЗ.к2 = 4;
	ТЗ.НоваяСтрока();
	ТЗ.к1 = 3; ТЗ.к2 = 6;
	ТЗ.НоваяСтрока();
	ТЗ.к1 = 4; ТЗ.к2 = 8;
	ТЗ.НоваяСтрока();
	ТЗ.к1 = 5; ТЗ.к2 = 10;

	ТЗ2 = СоздатьОбъект("ИндексированнаяТаблица");
	ТЗ2.Загрузить(ТЗ, "");

	ТЗ = ТЗ2;

	ТЗ.ВыбратьСтроки();

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 1);
	Сам.ПроверитьРавенство(ТЗ.к2, 2);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 1);

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 2);
	Сам.ПроверитьРавенство(ТЗ.к2, 4);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 2);

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 3);
	Сам.ПроверитьРавенство(ТЗ.к2, 6);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 3);

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 4);
	Сам.ПроверитьРавенство(ТЗ.к2, 8);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 4);

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 5);
	Сам.ПроверитьРавенство(ТЗ.к2, 10);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 5);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестОбъединить() Экспорт
	Сам = Сам();
	ТЗ1 = Выборка_ЗаполнитьТЗ();
	ТЗ2 = Выборка_ЗаполнитьТЗ_Док();
	н1 = ТЗ1.КоличествоСтрок();
	н2 = ТЗ2.КоличествоСтрок();

	ТЗ1.Объединить(ТЗ2);

	//_РедакторТЗ(ТЗ1);

	Сам.ПроверитьРавенство(ТЗ1.КоличествоСтрок(), н1 + н2);
	Сам.ПроверитьРавенство(ТЗ1.Итог("к1"), 36 + 21);
	Сам.ПроверитьРавенство(ТЗ1.НомерКолонки("Док"), 3);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестЗагрузитьРасш() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();

	ТЗ2 = СоздатьОбъект("ИндексированнаяТаблица");
	ТЗ2.Загрузить(ТЗ);

	ТЗ = ТЗ2;

	ТЗ.ВыбратьСтроки();

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 5);
	Сам.ПроверитьРавенство(ТЗ.к2, 1);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 1);

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 15);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 2);

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 5);
	Сам.ПроверитьРавенство(ТЗ.к2, 2);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 3);

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 10);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 4);

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 1);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 5);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестЗагрузитьСФильтром() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();

	ТЗ.ДобавитьИндекс("ДляЗагрузки", "к1");
	сзКлючМин = СоздатьОбъект("СписокЗначений");
	сзКлючМин.ДобавитьЗначение(6);
	сзКлючМакс = СоздатьОбъект("СписокЗначений");
	сзКлючМакс.ДобавитьЗначение(100);
	ТЗ.УстановитьФильтр(сзКлючМин, сзКлючМакс, "ДляЗагрузки");

	ТЗ2 = СоздатьОбъект("ИндексированнаяТаблица");
	ТЗ2.Загрузить(ТЗ, "ДляЗагрузки");

	ТЗ = ТЗ2;

	ТЗ.ВыбратьСтроки();

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 10);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 1);

	ТЗ.ПолучитьСтроку();
	Сам.ПроверитьРавенство(ТЗ.к1, 15);
	Сам.ПроверитьРавенство(ТЗ.НомерСтроки, 2);

	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестЗагрузитьДок() Экспорт
	Сам = Сам();

	Док = СоздатьОбъект("Документ.Новый1");
	Док.Новый();
	Док.НоваяСтрока();
	Док.новый1 = "стр 1";
	Док.НоваяСтрока();
	Док.новый1 = "стр 2";

	ТЗ = ТЗ();
	ТЗ.Загрузить(Док);
	Сам.ПроверитьРавенство(ТЗ.КоличествоСтрок(), 2);
	Сам.ПроверитьРавенство(СокрЛП(ТЗ.Получить(1, "новый1")), "стр 1");
	Сам.ПроверитьРавенство(СокрЛП(ТЗ.Получить(2, "новый1")), "стр 2");


	Док.Записать();
	ТЗ = ТЗ();
	ТЗ.Загрузить(Док);
	Сам.ПроверитьРавенство(ТЗ.КоличествоСтрок(), 2);

	ТЗ.Загрузить(Док.ТекущийДокумент());
	Сам.ПроверитьРавенство(ТЗ.КоличествоСтрок(), 2);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестЗагрузитьЗапрос() Экспорт
	Сам = Сам();

	Док = СоздатьОбъект("Документ.Новый1");
	Док.Новый();
	Док.ДатаДок = '01.01.2000';
	Док.НомерДок = 10;
	Док.Шапка2 = 10;
	Док.Записать();

	Док.Новый();
	Док.ДатаДок = '01.01.2000';
	Док.НомерДок = 20;
	Док.Шапка2 = 20;
	Док.Записать();

	ТекстЗапроса = "
	|Период с '01.01.2000' по '01.01.2000';
	|Обрабатывать Все;
	|ОбрабатыватьДокументы Все;
	|
	|Док = Документ.Новый1.ТекущийДокумент;
	|Номер = Документ.Новый1.НомерДок;
	|Шапка2 = Документ.Новый1.Шапка2;
	|
	|Функция Шапка = Сумма(Шапка2);
	|Группировка Номер;
	|Группировка Док;
	|";
	Запрос = СоздатьОбъект("Запрос");
	Запрос.Выполнить(ТекстЗапроса);
	ТЗ = ТЗ();
	ТЗ.ЗагрузитьЗапрос(Запрос, 0, 0);

	Сам.ПроверитьРавенство(ТЗ.КоличествоСтрок(), 2);
	Сам.ПроверитьРавенство(СокрЛП(ТЗ.Получить(1, "Номер")), "10");
	Сам.ПроверитьРавенство(СокрЛП(ТЗ.Получить(2, "Номер")), "20");
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестПересечение() Экспорт
	Сам = Сам();
	ТЗ1 = Выборка_ЗаполнитьТЗ();

	ТЗ2 = ТЗ();
	ТЗ2.НоваяКолонка("К1");
	ТЗ2.НоваяКолонка("К2");
	ТЗ2.НоваяКолонка("К3");

	ТЗ2.НоваяСтрока();
	ТЗ2.к1 = 5;  ТЗ2.к2 = "стр 1"; ТЗ2.к3 = "стр 1 к3";

	ТЗ2.НоваяСтрока();
	ТЗ2.к1 = 10; ТЗ2.к2 = "стр 2"; ТЗ2.к3 = "стр 2 к3";

	ТЗ2.НоваяСтрока();
	ТЗ2.к1 = 10; ТЗ2.к2 = "стр 3"; ТЗ2.к3 = "стр 3 к3";

	ТЗ2.НоваяСтрока();
	ТЗ2.к1 = 11; ТЗ2.к2 = "стр 4"; ТЗ2.к3 = "стр 4 к3";

	ТЗ1.ДобавитьИндекс("И1", "к1");
	ТЗ2.ДобавитьИндекс("И1", "к1");
	ТЗ1.Пересечение(ТЗ2, "И1", "И1");

	//_РедакторТЗ(ТЗ1);

	Сам.ПроверитьРавенство(ТЗ1.КоличествоСтрок(), 6);
	Сам.ПроверитьРавенство(ТЗ1.КоличествоКолонок(), 3);

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

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

	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(3, "к1"), 10);
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(3, "к2"), ПолучитьПустоеЗначение());

	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(4, "к1"), 5);
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(4, "к2"), "стр 1");
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(4, "к3"), "стр 1 к3");

	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(5, "к1"), 10);
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(5, "к2"), "стр 2");
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(5, "к3"), "стр 2 к3");

	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(6, "к1"), 10);
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(6, "к2"), "стр 3");
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(6, "к3"), "стр 3 к3");
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестПересечениеСРазнымиКолонками() Экспорт
	Сам = Сам();
	ТЗ1 = Выборка_ЗаполнитьТЗ();

	ТЗ2 = ТЗ();
	ТЗ2.НоваяКолонка("КК1");
	ТЗ2.НоваяКолонка("КК2");
	ТЗ2.НоваяКолонка("КК3");

	ТЗ2.НоваяСтрока();
	ТЗ2.кк1 = 5;  ТЗ2.кк2 = "стр 1"; ТЗ2.кк3 = "стр 1 к3";

	ТЗ2.НоваяСтрока();
	ТЗ2.кк1 = 10; ТЗ2.кк2 = "стр 2"; ТЗ2.кк3 = "стр 2 к3";

	ТЗ2.НоваяСтрока();
	ТЗ2.кк1 = 10; ТЗ2.кк2 = "стр 3"; ТЗ2.кк3 = "стр 3 к3";

	ТЗ2.НоваяСтрока();
	ТЗ2.кк1 = 11; ТЗ2.кк2 = "стр 4"; ТЗ2.кк3 = "стр 4 к3";

	ТЗ1.ДобавитьИндекс("И1", "к1");
	ТЗ2.ДобавитьИндекс("И1", "кк1");
	ТЗ1.Пересечение(ТЗ2, "И1", "И1");

//	_РедакторТЗ(ТЗ1);

	Сам.ПроверитьРавенство(ТЗ1.КоличествоСтрок(), 6);
	Сам.ПроверитьРавенство(ТЗ1.КоличествоКолонок(), 5);

	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(1, "к1"), 5);
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(1, "к2"), 1);
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(1, "кк1"), ПолучитьПустоеЗначение());
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(1, "кк2"), ПолучитьПустоеЗначение());
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(1, "кк3"), ПолучитьПустоеЗначение());

	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(2, "к1"), 5);
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(2, "к2"), 2);
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(2, "кк1"), ПолучитьПустоеЗначение());
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(2, "кк2"), ПолучитьПустоеЗначение());
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(2, "кк3"), ПолучитьПустоеЗначение());

	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(3, "к1"), 10);
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(3, "к2"), ПолучитьПустоеЗначение());
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(3, "кк1"), ПолучитьПустоеЗначение());
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(3, "кк2"), ПолучитьПустоеЗначение());
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(3, "кк3"), ПолучитьПустоеЗначение());

	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(4, "к1"), ПолучитьПустоеЗначение());
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(4, "к2"), ПолучитьПустоеЗначение());
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(4, "кк1"), 5);
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(4, "кк2"), "стр 1");
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(4, "кк3"), "стр 1 к3");

	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(5, "к1"), ПолучитьПустоеЗначение());
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(5, "к2"), ПолучитьПустоеЗначение());
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(5, "кк1"), 10);
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(5, "кк2"), "стр 2");
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(5, "кк3"), "стр 2 к3");

	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(6, "к1"), ПолучитьПустоеЗначение());
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(6, "к2"), ПолучитьПустоеЗначение());
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(6, "кк1"), 10);
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(6, "кк2"), "стр 3");
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(6, "кк3"), "стр 3 к3");
КонецПроцедуры

//______________________________________________________________________________
Процедура тестРазность() Экспорт
	Сам = Сам();
	ТЗ1 = ТЗ();

	ТЗ1.НоваяКолонка("к1");
	ТЗ1.НоваяКолонка("к2");
	_ДобавитьСтроку(ТЗ1, 1, 2);
	_ДобавитьСтроку(ТЗ1, 2, 4);
	_ДобавитьСтроку(ТЗ1, 9, 6);
	_ДобавитьСтроку(ТЗ1, 3, 4);

	_т2 = ТЗ();
	_т2.НоваяКолонка("к1");
	_т2.НоваяКолонка("к2");
	_ДобавитьСтроку(_т2, "А", "Б");
	_ДобавитьСтроку(_т2, 2, 4);
	_ДобавитьСтроку(_т2, "У", "ф");
	_ДобавитьСтроку(_т2, 9, 6);

	ТЗ1.ДобавитьИндекс("и1", "к1");
	_т2.ДобавитьИндекс("и1", "к1");

	ТЗ1.Разность(_т2, "и1", "и1");

	Сам.ПроверитьРавенство(ТЗ1.КоличествоСтрок(), 4);
	Сам.ПроверитьРавенство(ТЗ1.КоличествоКолонок(), 2);

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

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

	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(3, "к1"), "А");
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(3, "к2"), "Б");

	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(4, "к1"), "У");
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(4, "к2"), "ф");

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

//______________________________________________________________________________
Процедура тестРазностьСРазнымиКолонками() Экспорт
	Сам = Сам();
	ТЗ1 = ТЗ();

	ТЗ1.НоваяКолонка("к1");
	ТЗ1.НоваяКолонка("к2");
	_ДобавитьСтроку(ТЗ1, 1, 2);
	_ДобавитьСтроку(ТЗ1, 2, 4);
	_ДобавитьСтроку(ТЗ1, 2, 6);
	_ДобавитьСтроку(ТЗ1, 9, 6);
	_ДобавитьСтроку(ТЗ1, 3, 4);

	_т2 = ТЗ();
	_т2.НоваяКолонка("кк1");
	_т2.НоваяКолонка("кк2");
	_ДобавитьСтроку(_т2, "А", "Б");
	_ДобавитьСтроку(_т2, 2, 4);
	_ДобавитьСтроку(_т2, "У", "ф");
	_ДобавитьСтроку(_т2, 9, 6);

	ТЗ1.ДобавитьИндекс("и1", "к1");
	_т2.ДобавитьИндекс("и1", "кк1");

	ТЗ1.Разность(_т2, "и1", "и1");

	Сам.ПроверитьРавенство(ТЗ1.КоличествоСтрок(), 4);
	Сам.ПроверитьРавенство(ТЗ1.КоличествоКолонок(), 4);

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

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

	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(3, "к1"), ПолучитьПустоеЗначение());
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(3, "к2"), ПолучитьПустоеЗначение());
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(3, "кк1"), "А");
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(3, "кк2"), "Б");

	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(4, "к1"), ПолучитьПустоеЗначение());
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(4, "к2"), ПолучитьПустоеЗначение());
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(4, "кк1"), "У");
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(4, "кк2"), "ф");
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестЗаполнить() Экспорт
	Сам = Сам();
	ТЗ1 = ТЗ();
	ТЗ1.НоваяКолонка("К1");
	ТЗ1.НоваяКолонка("К2");
	ТЗ1.НоваяКолонка("К3");

	ТЗ2 = Выборка_ЗаполнитьТЗ();

	ТЗ1.НоваяСтрока();
	ТЗ1.НоваяСтрока();
	ТЗ1.НоваяСтрока();

	//ТЗ1.Заполнить(ТЗ2, );
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестКопия() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();
	ТЗ.Сортировать("к1");
	ТЗ.ДобавитьИндекс("и1", "к1, к2");

	ТЗ2 = ТЗ.Копия(1);

	Сам.ПроверитьРавенство(ТЗ.КоличествоСтрок(), ТЗ2.КоличествоСтрок());
	Сам.ПроверитьРавенство(ТЗ.КоличествоКолонок(), ТЗ2.КоличествоКолонок());

	Для стр = 1 По ТЗ.КоличествоСтрок() Цикл
		Для кол = 1 По ТЗ.КоличествоКолонок() Цикл
			Сам.ПроверитьРавенство(ТЗ.Получить(стр, кол), ТЗ2.Получить(стр, кол));
		КонецЦикла;
	КонецЦикла;

	//_РедакторТЗ(ТЗ2, "и1");


	сзКлюч = СоздатьОбъект("СписокЗначений");
	сзКлюч.ДобавитьЗначение(15);
	Сам.ПроверитьРавенство(ТЗ.НайтиСтроку(, сзКлюч), 2);

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

//_____________________________________________________________________________
Процедура тестКопияБезДанных() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();

	ТЗ2 = ТЗ.Копия(0, 0);
	Сам.ПроверитьРавенство(ТЗ2.КоличествоСтрок(), 0);
	Сам.ПроверитьРавенство(ТЗ2.КоличествоКолонок(), ТЗ.КоличествоКолонок());
	Сам.ПроверитьРавенство(НРег(ТЗ2.ИмяКолонки(1)), "к1");
	Сам.ПроверитьРавенство(Нрег(ТЗ2.ИмяКолонки(2)), "к2");
КонецПроцедуры


//_____________________________________________________________________________
Процедура СравнитьТЗ(ТЗ1, ТЗ2, Индекс = "")
	Сам = Сам();
	Сам.ПроверитьРавенство(ТЗ1.КоличествоСтрок(Индекс),   ТЗ2.КоличествоСтрок());
	Сам.ПроверитьРавенство(ТЗ1.КоличествоКолонок(), ТЗ2.КоличествоКолонок());

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

//_____________________________________________________________________________
Процедура СравнитьТЗПоПредставлениям(ТЗ1, ТЗ2, Индекс = "")
	Сам = Сам();
	Сам.ПроверитьРавенство(ТЗ1.КоличествоСтрок(Индекс),   ТЗ2.КоличествоСтрок());
	Сам.ПроверитьРавенство(ТЗ1.КоличествоКолонок(), ТЗ2.КоличествоКолонок());

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

//_____________________________________________________________________________
Процедура тестВФайл() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ_Док();
	ТЗ2 = Выборка_ЗаполнитьТЗ_Спр();
	ТЗ.УстановитьЗначение(1, 2, ТЗ2);
	ТЗ.УстановитьЗначение(6, "к1", "стр1""стр2");
	ТЗ.УстановитьЗначение(6, "к2", "стр1;стр2");
	ТЗ.ВФайл(КаталогИБ()+"тестВФайл1.ТЗ");
	ТЗ.ВФайл(КаталогИБ()+"тестВФайл2.ТЗ", 2);
	ТЗ.ВФайл(КаталогИБ()+"тестВФайл1.csv", 3);
	ТЗ.ВФайл(КаталогИБ()+"тестВФайл2.csv", 4);

	ТЗ2 = ТЗ();
	ТЗ2.ИзФайла(КаталогИБ()+"тестВФайл1.ТЗ");
	СравнитьТЗ(ТЗ, ТЗ2);

	ТЗ2.ИзФайла(КаталогИБ()+"тестВФайл2.ТЗ");
	СравнитьТЗПоПредставлениям(ТЗ, ТЗ2);

	ТЗ2.ИзФайла(КаталогИБ()+"тестВФайл1.csv", 3);
	//_РедакторТЗ(ТЗ);
	//_РедакторТЗ(ТЗ2);
	СравнитьТЗПоПредставлениям(ТЗ, ТЗ2);

	ТЗ2.ИзФайла(КаталогИБ()+"тестВФайл2.csv", 4);
	//_РедакторТЗ(ТЗ2);
	СравнитьТЗПоПредставлениям(ТЗ, ТЗ2);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестВФайлСортировка() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ_Док();

	ТЗ.ДобавитьИндекс("и1", "ДатаДок, СтрДок");
	ТЗ.ВФайл(КаталогИБ()+"тестВФайл1.ТЗ", 1, "и1");
	ТЗ.ВФайл(КаталогИБ()+"тестВФайл2.csv", 4, "и1");

	ТЗ2 = ТЗ();
	ТЗ2.ИзФайла(КаталогИБ()+"тестВФайл1.ТЗ");
	СравнитьТЗ(ТЗ, ТЗ2, "и1");

	ТЗ2.ИзФайла(КаталогИБ()+"тестВФайл2.csv", 4);
	СравнитьТЗПоПредставлениям(ТЗ, ТЗ2, "и1");
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестВФайлСортировкаУник() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ_Док();

	ТЗ.ДобавитьИндекс("и1", "СтрДок", 1);
	ТЗ.ВФайл(КаталогИБ()+"тестВФайл1.ТЗ", 1, "и1");
	ТЗ.ВФайл(КаталогИБ()+"тестВФайл2.csv", 4, "и1");

	ТЗ2 = ТЗ();
	ТЗ2.ИзФайла(КаталогИБ()+"тестВФайл1.ТЗ");
	СравнитьТЗ(ТЗ, ТЗ2, "и1");

	ТЗ2.ИзФайла(КаталогИБ()+"тестВФайл2.csv", 4);
	СравнитьТЗПоПредставлениям(ТЗ, ТЗ2, "и1");
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестВФайлФильтр() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ_Док();

	ТЗ.ДобавитьИндекс("и1", "ДатаДок");
	ТЗ.УстановитьФильтр('03.01.2005', '03.01.2005', "и1");

	ТЗ.ВФайл(КаталогИБ()+"тестВФайл1.ТЗ", 1, "и1");
	ТЗ.ВФайл(КаталогИБ()+"тестВФайл2.csv", 4, "и1");

	ТЗ2 = ТЗ();
	ТЗ2.ИзФайла(КаталогИБ()+"тестВФайл1.ТЗ");
	СравнитьТЗ(ТЗ, ТЗ2, "и1");
//
//	ТЗ2.ИзФайла(КаталогИБ()+"тестВФайл2.csv", 4);
//	СравнитьТЗПоПредставлениям(ТЗ, ТЗ2, "и1");
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестВФайлСЗ() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ_Док();

	Сп = СоздатьОбъект("СписокЗначений");
	Сп.ДобавитьЗначение(1, "Зн 1");
	Сп.ДобавитьЗначение(2, "Зн 2");

	ТЗ.УстановитьЗначение(1, 1, Сп);
	ТЗ.ВФайл(КаталогИБ()+"тестВФайлСЗ.ТЗ");
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестИзСтроки() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ_Док();

	Стр = ЗначениеВСтрокуВнутр(ТЗ);
	ТЗ2 = ТЗ();
	ТЗ2.ИзСтроки(Стр);
	СравнитьТЗ(ТЗ, ТЗ2);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестИзСтрокиВнешн() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ_Док();

	Стр = ТЗ.ВСтроку(0);
	ТЗ2 = ТЗ();
	ТЗ2.ИзСтроки(Стр);
	СравнитьТЗПоПредставлениям(ТЗ, ТЗ2);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестИзСтрокиПустаяДата() Экспорт
	Сам = Сам();
	
	ТЗ = СоздатьОбъект("ИндексированнаяТаблица");
	ТЗ.НоваяКолонка("Дата");
	ТЗ.НоваяСтрока();
	ТЗ.Дата = '';
	
	Стр = ТЗ.ВСтроку(0);
	ТЗ2 = СоздатьОбъект("ИндексированнаяТаблица");
	ТЗ2.ИзСтроки(Стр);
	
	СравнитьТЗ(ТЗ, ТЗ2);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестИзСтрокиДатаМеньше2000() Экспорт
	Сам = Сам();
	
	ТЗ = СоздатьОбъект("ИндексированнаяТаблица");
	ТЗ.НоваяКолонка("Дата");
	ТЗ.НоваяСтрока();
	ТЗ.Дата = '25.12.1812';
	
	Стр = ТЗ.ВСтроку(0);
	ТЗ2 = СоздатьОбъект("ИндексированнаяТаблица");
	ТЗ2.ИзСтроки(Стр);
	
	СравнитьТЗ(ТЗ, ТЗ2);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестИзФайлаДата() Экспорт
	Сам = Сам();
	
	ТЗ = СоздатьОбъект("ИндексированнаяТаблица");
	ТЗ.НоваяКолонка("Дата");
	ТЗ.НоваяСтрока();
	ТЗ.Дата = '';
	ТЗ.НоваяСтрока();
	ТЗ.Дата = Дата(1812, 12, 25);
	
	ТЗ.ВФайл(КаталогИБ()+"тестИзФайлаДата.ТЗ", 2);
	ТЗ2 = СоздатьОбъект("ИндексированнаяТаблица");
	ТЗ2.ИзФайла(КаталогИБ()+"тестИзФайлаДата.ТЗ", 2);

	СравнитьТЗ(ТЗ, ТЗ2);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестВСтрокуСФильтром() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ_Док();
	ТЗ.ДобавитьИндекс("и1", "ДатаДок");
	ТЗ.УстановитьФильтр('03.01.2005', '03.01.2005', "и1");

	Стр = ТЗ.ВСтроку(, "и1");
	ТЗ2 = ТЗ();
	ТЗ2.ИзСтроки(Стр);
	СравнитьТЗ(ТЗ, ТЗ2, "и1");
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестНайтиСтрокуВПодмножествеБезИндекса() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();
	ТЗ.Сортировать("к1,к2");

	сзФильтр = СоздатьОбъект("СписокЗначений");
	сзФильтр.Установить("к1", 5);
	ТЗ.Подмножество(сзФильтр, 1);

	Ключ = СоздатьОбъект("СписокЗначений");
	Ключ.Установить("к1", 5);
	Ключ.Установить("к2", 2);

	Сам.ПроверитьРавенство(ТЗ.НайтиСтроку(, Ключ), 3);

	Ключ.Установить("к2", 1);
	Сам.ПроверитьРавенство(ТЗ.НайтиСтроку(, Ключ), 1);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестНайтиСтрокуВПодмножествеСИндексом() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();
	//ТЗ.Сортировать("к1,к2");
	ТЗ.ДобавитьИндекс("к", "к1,к2");

	сзФильтр = СоздатьОбъект("СписокЗначений");
	сзФильтр.Установить("к1", 5);
	ТЗ.Подмножество(сзФильтр, 1, "к");

	Ключ = СоздатьОбъект("СписокЗначений");
	Ключ.Установить("к1", 5);
	Ключ.Установить("к2", 2);

	Сам.ПроверитьРавенство(ТЗ.НайтиСтроку("к", Ключ), 3);

	Ключ.Установить("к2", 1);
	Сам.ПроверитьРавенство(ТЗ.НайтиСтроку("к", Ключ), 1);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестНайтиСтрокуВПодмножествеБезИндекса2() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();
	ТЗ.Сортировать("к1,к2");

	сзФильтр = СоздатьОбъект("СписокЗначений");
	сзФильтр.ДобавитьЗначение(5);
	ТЗ.Подмножество(сзФильтр, 1);

	Ключ = СоздатьОбъект("СписокЗначений");
	Ключ.Установить("к1", 5);
	Ключ.Установить("к2", 2);

	Сам.ПроверитьРавенство(ТЗ.НайтиСтроку(, Ключ), 3);

	Ключ.Установить("к2", 1);
	Сам.ПроверитьРавенство(ТЗ.НайтиСтроку(, Ключ), 1);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестНайтиСтрокуВПодмножествеСИндексом2() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();
	//ТЗ.Сортировать("к1,к2");
	ТЗ.ДобавитьИндекс("к", "к1,к2");

	сзФильтр = СоздатьОбъект("СписокЗначений");
	сзФильтр.ДобавитьЗначение(5);
	ТЗ.Подмножество(сзФильтр, 1, "к");

	Ключ = СоздатьОбъект("СписокЗначений");
	Ключ.Установить("к1", 5);
	Ключ.Установить("к2", 2);

	Сам.ПроверитьРавенство(ТЗ.НайтиСтроку("к", Ключ), 3);

	Ключ.Установить("к2", 1);
	Сам.ПроверитьРавенство(ТЗ.НайтиСтроку("к", Ключ), 1);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестНайтиСтрокуВПодмножествеСИндексомУникальности() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();
	//ТЗ.Сортировать("к1,к2");
	ТЗ.ДобавитьИндекс("к", "к1,к2", 1);

	сзФильтр = СоздатьОбъект("СписокЗначений");
	сзФильтр.ДобавитьЗначение(5);
	ТЗ.Подмножество(сзФильтр, 1, "к");

	Ключ = СоздатьОбъект("СписокЗначений");
	Ключ.Установить("к1", 5);
	Ключ.Установить("к2", 2);

	Сам.ПроверитьРавенство(ТЗ.НайтиСтроку("к", Ключ), 3);

	Ключ.Установить("к2", 1);
	Сам.ПроверитьРавенство(ТЗ.НайтиСтроку("к", Ключ), 1);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестФильтрПоДвумИзмерениям() Экспорт
	Сам = Сам();

	ТЗ = ТЗ();
	ТЗ.НоваяКолонка("К1");
	ТЗ.НоваяКолонка("К2");

	ТЗ.НоваяСтрока(); //1
	ТЗ.к1 = 1; ТЗ.к2 = 1;

	ТЗ.НоваяСтрока(); //1
	ТЗ.к1 = 2; ТЗ.к2 = 2;

	ТЗ.НоваяСтрока(); //1
	ТЗ.к1 = 1; ТЗ.к2 = 3;

	ТЗ.НоваяСтрока(); //1
	ТЗ.к1 = 4; ТЗ.к2 = 4;

	ТЗ.ДобавитьИндекс("к", "к1,к2");

	сзКлючМин = СоздатьОбъект("СписокЗначений");
	сзКлючМакс = СоздатьОбъект("СписокЗначений");

	сзКлючМин.Установить("к1", 1);
	сзКлючМакс.Установить("к1", 2);

	сзКлючМин.Установить("к2", 1);
	сзКлючМакс.Установить("к2", 2);
	ТЗ.УстановитьФильтр(сзКлючМин, сзКлючМакс, "к");

	//ТЗ.Показать("", "", 0, "к");

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

	ТЗ.ВыбратьСтроки("к");

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

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

	ТЗ.ПолучитьСтроку("к");
	Сам.ПроверитьРавенство(ТЗ.к1, 2);
	Сам.ПроверитьРавенство(ТЗ.к2, 2);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестВыбратьСтроку() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();

//	ТЗ.ВыбратьСтроку("");
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестПоказать() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();

    ТЗ.ДобавитьИндекс("к1", "к1");
	//ТЗ.Показать("к1");
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестВыбратьСтрокиПоИндексу() Экспорт
	Сам =Сам();
	ТЗ = ТЗ();
	ТЗ.НоваяКолонка("К1");
	ТЗ.НоваяКолонка("К2");
	ТЗ.НоваяКолонка("К3");
	ТЗ.НоваяКолонка("К4");
	ТЗ.НоваяКолонка("К5");
	ТЗ.НоваяКолонка("К6");
	_ДобавитьСтроку(ТЗ, 1, 1);
	_ДобавитьСтроку(ТЗ, 1, 1);
	_ДобавитьСтроку(ТЗ, 2, 2);
	_ДобавитьСтроку(ТЗ, 5, 5);
	_ДобавитьСтроку(ТЗ, 5, 5);

	ТЗ.ДобавитьИндекс("К1", "*К1");
	ТЗ.ДобавитьИндекс("К2", "*К2", 1);

	ТЗ.ВыбратьСтроки("К1");
	// падает, если не задан индекс
	Сам.ПроверитьРавенство(ТЗ.ПолучитьСтроку(""), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестРеиндексацияПриУдалении() Экспорт
	// реиндексация при удалении строки с неуникальным индексом

	Сам =Сам();
	_т =ТЗ();
	_т.НоваяКолонка("НомерСтроки");
	_т.НоваяКолонка("Значение");

	_ДобавитьСтроку(_т, 1, 10);
	_ДобавитьСтроку(_т, 2, 20);
	_ДобавитьСтроку(_т, 3, 10);
	_ДобавитьСтроку(_т, 4, 20);
	_ДобавитьСтроку(_т, 5, 10);
	_ДобавитьСтроку(_т, 6, 20);
	
	_т.ДобавитьИндекс("Ключ", "Значение");

	_ти =_т.Копия(1, 1);
	// так работает
	Пока _ти.НайтиСтроку("Ключ", 10, 1, 1) >0 Цикл
		_ти.УдалитьСтроку(_ти.НомерСтроки);
	КонецЦикла;
	Сам.ПроверитьРавенство(_ти.КоличествоСтрок(), 3);
	Сам.ПроверитьРавенство(_ти.Итог("Значение"), 60);
	
	_ти =_т.Копия(1, 1);
	// так не работает
	Пока _ти.НайтиСтроку("Ключ", 10, 0, 1) >0 Цикл
		_ти.УдалитьСтроку(_ти.НомерСтроки);
	КонецЦикла;
	Сам.ПроверитьРавенство(_ти.КоличествоСтрок(), 3);
	Сам.ПроверитьРавенство(_ти.Итог("Значение"), 60);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестКоличествоСтрокПоИндексу_УникальныйИтератор() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();
	ТЗ.ДобавитьИндекс("к1","к1", 0); // БЕЗ УНИКАЛЬНОСТИ
	Сам.ПроверитьРавенство(ТЗ.КоличествоСтрок("к1", 1), 4);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестКоличествоСтрокПоФильтру_УникальныйИтератор() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();
	ТЗ.Сортировать("к1");
	ТЗ.УстановитьФильтр(5, 11);
	Сам.ПроверитьРавенство(ТЗ.КоличествоСтрок(, 1), 2);
КонецПроцедуры

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

	ТЗ.СледующаяСтрока("к1");
	Сам.ПроверитьРавенство(ТЗ.к1, 5);

	ТЗ.СледующаяСтрока("к1");
	Сам.ПроверитьРавенство(ТЗ.к1, 10);

	ТЗ.СледующаяСтрока("к1");
	Сам.ПроверитьРавенство(ТЗ.к1, 15);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестВНачало_СледующаяСтрока_СФильтром_УникальныйИтератор() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();
	ТЗ.ДобавитьИндекс("к1","к1", 0);
	ТЗ.УстановитьФильтр(5, 11, "к1");
	
	ТЗ.ВНачало("к1", 1); // уникальная выборка
	
	ТЗ.СледующаяСтрока("к1");
	Сам.ПроверитьРавенство(ТЗ.к1, 5);

	ТЗ.СледующаяСтрока("к1");
	Сам.ПроверитьРавенство(ТЗ.к1, 10);

	Сам.ПроверитьРавенство(ТЗ.СледующаяСтрока("к1"), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестВКонец_ПредыдущаяСтрока_СФильтром_УникальныйИтератор() Экспорт
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();
	ТЗ.ДобавитьИндекс("к1","к1", 0);
	ТЗ.УстановитьФильтр(5, 11, "к1");
	
	ТЗ.ВКонец("к1", 1); // уникальная выборка
	
	ТЗ.ПредыдущаяСтрока("к1");
	Сам.ПроверитьРавенство(ТЗ.к1, 10);

	ТЗ.ПредыдущаяСтрока("к1");
	Сам.ПроверитьРавенство(ТЗ.к1, 5);

	Сам.ПроверитьРавенство(ТЗ.ПредыдущаяСтрока("к1"), 0);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестВыгрузить_УникальныйИтератор() Экспорт
	Перем _т;
	
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();
	ТЗ.ДобавитьИндекс("к1","к1", 0);
	
	ТЗ.Выгрузить(_т, "к1", , 1);
	Сам.ПроверитьРавенство(_т.Итог("к1"), 31);

	_т =СоздатьОбъект("ТаблицаЗначений");
	ТЗ.Выгрузить(_т, "к1", , 1);
	Сам.ПроверитьРавенство(_т.Итог("к1"), 31);
	
	_сз =СоздатьОбъект("СписокЗначений");
	ТЗ.Выгрузить(_сз, "к1", "к1", 1);
	Сам.ПроверитьРавенство(_сз.ВСтрокуСРазделителями(), "1,5,10,15");
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестВыгрузитьСФильтром_УникальныйИтератор() Экспорт
	Перем _т;
	
	Сам = Сам();
	ТЗ = Выборка_ЗаполнитьТЗ();
	ТЗ.ДобавитьИндекс("к1","к1", 0);
	ТЗ.УстановитьФильтр(5, 11, "к1");
	
	// неуникальный итератор
	ТЗ.Выгрузить(_т, "к1", , 0);
	Сам.ПроверитьРавенство(_т.Итог("к1"), 20);

	// уникальный итератор
	ТЗ.Выгрузить(_т, "к1", , 1);
	Сам.ПроверитьРавенство(_т.Итог("к1"), 15);

	_т =СоздатьОбъект("ТаблицаЗначений");
	ТЗ.Выгрузить(_т, "к1", , 1);
	Сам.ПроверитьРавенство(_т.Итог("к1"), 15);
	
	_сз =СоздатьОбъект("СписокЗначений");
	ТЗ.Выгрузить(_сз, "к1", "к1", 1);
	Сам.ПроверитьРавенство(_сз.ВСтрокуСРазделителями(), "5,10");
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестВыгрузитьДок_УникальныйИтератор() Экспорт
	Сам = Сам();
	ТЗ = ТЗ();
	ТЗ.НоваяКолонка("Новый1");
	ТЗ.НоваяКолонка("Кол");
	_ДобавитьСтроку(ТЗ, 1, 1);
	_ДобавитьСтроку(ТЗ, 5, 1);
	_ДобавитьСтроку(ТЗ, 5, 1);
	_ДобавитьСтроку(ТЗ, 10, 1);
	_ДобавитьСтроку(ТЗ, 15, 1);
	ТЗ.ДобавитьИндекс("к1","Новый1", 0);

	Док = СоздатьОбъект("Документ.Новый1");
	Док.Новый();
	ТЗ.Выгрузить(Док, "к1", , 1);

	Сам.ПроверитьРавенство(Док.КоличествоСтрок(), 4);
	Док.ПолучитьСтрокуПоНомеру(1);
	Сам.ПроверитьРавенство(Число(Док.новый1), 1);
	Док.ПолучитьСтрокуПоНомеру(2);
	Сам.ПроверитьРавенство(Число(Док.новый1), 5);
	Док.ПолучитьСтрокуПоНомеру(3);
	Сам.ПроверитьРавенство(Число(Док.новый1), 10);
	Док.ПолучитьСтрокуПоНомеру(4);
	Сам.ПроверитьРавенство(Число(Док.новый1), 15);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестВыгрузитьДокСФильтром_УникальныйИтератор() Экспорт
	Сам = Сам();
	ТЗ = ТЗ();
	ТЗ.НоваяКолонка("Новый1");
	ТЗ.НоваяКолонка("Кол");
	_ДобавитьСтроку(ТЗ, 1, 1);
	_ДобавитьСтроку(ТЗ, 5, 1);
	_ДобавитьСтроку(ТЗ, 5, 1);
	_ДобавитьСтроку(ТЗ, 10, 1);
	_ДобавитьСтроку(ТЗ, 15, 1);
	ТЗ.ДобавитьИндекс("к1","Новый1", 0);
	ТЗ.УстановитьФильтр(5, 11, "к1");

	Док = СоздатьОбъект("Документ.Новый1");
	Док.Новый();
	ТЗ.Выгрузить(Док, "к1", , 1);

	Сам.ПроверитьРавенство(Док.КоличествоСтрок(), 2);
	Док.ПолучитьСтрокуПоНомеру(1);
	Сам.ПроверитьРавенство(Число(Док.новый1), 5);
	Док.ПолучитьСтрокуПоНомеру(2);
	Сам.ПроверитьРавенство(Число(Док.новый1), 10);
КонецПроцедуры

//_____________________________________________________________________________
Процедура тестПересечение_ТолькоТЗ1() Экспорт
	Сам = Сам();
	ТЗ1 = Выборка_ЗаполнитьТЗ();

	ТЗ2 = ТЗ();
	ТЗ2.НоваяКолонка("К1");
	ТЗ2.НоваяКолонка("К2");
	ТЗ2.НоваяКолонка("К3");

	ТЗ2.НоваяСтрока();
	ТЗ2.к1 = 5;  ТЗ2.к2 = "стр 1"; ТЗ2.к3 = "стр 1 к3";

	ТЗ2.НоваяСтрока();
	ТЗ2.к1 = 10; ТЗ2.к2 = "стр 2"; ТЗ2.к3 = "стр 2 к3";

	ТЗ2.НоваяСтрока();
	ТЗ2.к1 = 10; ТЗ2.к2 = "стр 3"; ТЗ2.к3 = "стр 3 к3";

	ТЗ2.НоваяСтрока();
	ТЗ2.к1 = 11; ТЗ2.к2 = "стр 4"; ТЗ2.к3 = "стр 4 к3";

	ТЗ1.ДобавитьИндекс("И1", "к1");
	ТЗ2.ДобавитьИндекс("И1", "к1");
	ТЗ1.Пересечение(ТЗ2, "И1", "И1", 0);

	//_РедакторТЗ(ТЗ1);

	Сам.ПроверитьРавенство(ТЗ1.КоличествоСтрок(), 3);
	Сам.ПроверитьРавенство(ТЗ1.КоличествоКолонок(), 2);

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

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

	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(3, "к1"), 10);
	Сам.ПроверитьРавенство(ТЗ1.ПолучитьЗначение(3, "к2"), ПолучитьПустоеЗначение());

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

//_____________________________________________________________________________
Процедура тестРазность_ТолькоТЗ1() Экспорт
	Сам = Сам();
	ТЗ1 = ТЗ();

	ТЗ1.НоваяКолонка("к1");
	ТЗ1.НоваяКолонка("к2");
	_ДобавитьСтроку(ТЗ1, 1, 2);
	_ДобавитьСтроку(ТЗ1, 2, 4);
	_ДобавитьСтроку(ТЗ1, 9, 6);
	_ДобавитьСтроку(ТЗ1, 3, 4);

	_т2 = ТЗ();
	_т2.НоваяКолонка("к1");
	_т2.НоваяКолонка("к2");
	_ДобавитьСтроку(_т2, "А", "Б");
	_ДобавитьСтроку(_т2, 2, 4);
	_ДобавитьСтроку(_т2, "У", "ф");
	_ДобавитьСтроку(_т2, 9, 6);

	ТЗ1.ДобавитьИндекс("и1", "к1");
	_т2.ДобавитьИндекс("и1", "к1");

	ТЗ1.Разность(_т2, "и1", "и1", 0);

	Сам.ПроверитьРавенство(ТЗ1.КоличествоСтрок(), 2);
	Сам.ПроверитьРавенство(ТЗ1.КоличествоКолонок(), 2);

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

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

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

//______________________________________________________________________________
//
//http://cvs.alterplast.ru/bugs/show_bug.cgi?id=2368
//
Процедура тестИнверсныйФильтрПоПустойТаблице() Экспорт
	Сам = Сам();

	_т =СоздатьОбъект("ИндексированнаяТаблица");
	_т.НоваяКолонка("кол1");
	_т.ДобавитьИндекс("кол1", "кол1");
	_т.УстановитьФильтр(1, 1, "кол1", 0, 1);
	_т.УдалитьСтроки("кол1");

	Сам.ПроверитьРавенство(_т.КоличествоСтрок(), 0); // здесь был вылет; исправлено 02.07.2006
КонецПроцедуры

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

	_т.ДобавитьИндекс("кол1", "кол1");

	_т.ВКонец(2);

        // важно количество итераций: позиционирование на узел
	_т.ПредыдущаяСтрока(2);
	_т.ПредыдущаяСтрока(2);
	_т.ПредыдущаяСтрока(2);

	_т.СледующаяСтрока(2);
	Сам.ПроверитьРавенство(_т.НомерСтроки, 3); // позиционирование исправлено 13.12.2006

	_т.СледующаяСтрока(2);
	Сам.ПроверитьРавенство(_т.НомерСтроки, 4);
КонецПроцедуры

//______________________________________________________________________________
//
Процедура тестКоличествоИндексов() Экспорт
	Сам = Сам();

	_т =Выборка_ЗаполнитьТЗ();
	Сам.ПроверитьРавенство(_т.КоличествоИндексов(), 1);
	
	_т.ДобавитьИндекс("Инд1", "к1");
	_т.ДобавитьИндекс("Инд2", "к2,к1");
	Сам.ПроверитьРавенство(_т.КоличествоИндексов(), 3);
КонецПроцедуры

//______________________________________________________________________________
//
Процедура тестИмяИндекса() Экспорт
	Сам = Сам();

	_т =Выборка_ЗаполнитьТЗ();
	_т.ДобавитьИндекс("Инд1", "к1");
	_т.ДобавитьИндекс("Инд2", "*к2,^к1");

	Сам.ПроверитьРавенство(_т.ИмяИндекса(0), "");
	Сам.ПроверитьРавенство(_т.ИмяИндекса(1), "");
	Сам.ПроверитьРавенство(_т.ИмяИндекса(2), "Инд1");
	Сам.ПроверитьРавенство(_т.ИмяИндекса(3), "Инд2");
КонецПроцедуры

//______________________________________________________________________________
//
Процедура тестВыражениеИндекса() Экспорт
	Сам = Сам();

	_т =Выборка_ЗаполнитьТЗ();
	_т.ДобавитьИндекс("Инд1", "к1");
	_т.ДобавитьИндекс("Инд2", "*к2,^к1");

	Сам.ПроверитьРавенство(_т.ВыражениеИндекса(0), "");
	Сам.ПроверитьРавенство(_т.ВыражениеИндекса(1), "");
	Сам.ПроверитьРавенство(_т.ВыражениеИндекса(2), "к1");
	Сам.ПроверитьРавенство(_т.ВыражениеИндекса(3), "*к2,^к1");
КонецПроцедуры

//______________________________________________________________________________
//
Процедура тестНомерИндекса() Экспорт
	Сам = Сам();

	_т =Выборка_ЗаполнитьТЗ();
	_т.ДобавитьИндекс("Инд1", "к1");
	_т.ДобавитьИндекс("Инд2", "*к2,^к1");

	Сам.ПроверитьРавенство(_т.НомерИндекса(0), 1);
	Сам.ПроверитьРавенство(_т.НомерИндекса(1), 1);
	Сам.ПроверитьРавенство(_т.НомерИндекса(3), 3);
	Сам.ПроверитьРавенство(_т.НомерИндекса(""), 1);
	Сам.ПроверитьРавенство(_т.НомерИндекса("Инд2"), 3);
	Сам.ПроверитьРавенство(_т.НомерИндекса(4), 0);
КонецПроцедуры

//______________________________________________________________________________
//
Процедура тестСохранениеИтератора() Экспорт
	Сам = Сам();
	
	_т =Выборка_ЗаполнитьТЗ();
	_т.ДобавитьИндекс("Инд1", "к1");
	                                
	// результат 0 - выборка не открыта, нечего сохранять
	Сам.ПроверитьРавенство(_т.СохранитьИтератор(2), 0);

	// результат 0 - итератор не сохранялся
	Сам.ПроверитьРавенство(_т.ВосстановитьИтератор(2, 1), 0);
	
	_т.УстановитьФильтр(5, 10, 2, 0, 0);
	_т.ВыбратьСтроки(2);

	_т.ПолучитьСтроку(2);
	Сам.ПроверитьРавенство(_т.к1, 5);

	_т.ПолучитьСтроку(2);
	Сам.ПроверитьРавенство(_т.к1, 5);
	
	// сохраняем итератор 5, 5, <здесь> 10
	_т.СохранитьИтератор(2);

	_т.УстановитьФильтр(15, 15, 2, 0, 0);
	_т.ВыбратьСтроки(2);

	_т.ПолучитьСтроку(2);
	Сам.ПроверитьРавенство(_т.к1, 15);
	
	// восстанавливаем последний итератор
	_т.ВосстановитьИтератор(2);

	_т.ПолучитьСтроку(2);
	Сам.ПроверитьРавенство(_т.к1, 10);
	
	// фильтр 5, 10 - выборка закончена
	Сам.ПроверитьРавенство(_т.ПолучитьСтроку(2), 0);
КонецПроцедуры
