Перем
		OLEDBData,
		OLEDBCommand,
		ИмяКаталогаВременныхФайлов
		;

Функция Конт(Конт) Возврат Конт; КонецФункции // : Контекст
Функция Сам() Возврат Конт(Контекст); КонецФункции // : Контекст

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

	// проверю наличие провайдера
	//
	Попытка
		РеестрWin = СоздатьОбъект("РеестрWin"); // это синоним
	Исключение
		РеестрWin = СоздатьОбъект("РаботаСРегистромWin"); // это старое название
	КонецПопытки;
	
	Если РеестрWin.ОткрытьКлюч("HKEY_CLASSES_ROOT", "VFPOLEDB.1", "KEY_READ") = 0 Тогда
		Сам().ПропуститьТест(, "Не установлен провайдер VFP OLE DB");
	КонецЕсли;
КонецПроцедуры // Конструктор

//_____________________________________________________________________________
//
Функция OLEDBData()
	Возврат СоздатьОбъект("OLEDBData");
КонецФункции // OLEDBData()

//_____________________________________________________________________________
//
Функция OLEDBData_СоздатьИСоединить()
	OLEDBData = OLEDBData();

	СтрокаПодключения =
	"Provider=VFPOLEDB.1;
	|Deleted=Yes;
	|Data Source=" + КаталогИБ() + ";
	|Mode=ReadWrite;
	|Mask Password=False;
	|Collating Sequence=RUSSIAN;
	//|OLE DB Services=0;
	|";
	
	лРезультатСоединения = OLEDBData.Соединение(СтрокаПодключения);
	Сам().ПроверитьРавенство(лРезультатСоединения, 1);

	Возврат OLEDBData;
КонецФункции // OLEDBData_СоздатьИСоединить()

//_____________________________________________________________________________
//
Функция СоздатьИСоединить()
	OLEDBData = OLEDBData();

	СтрокаПодключения =
	"Provider=VFPOLEDB.1;
	|Deleted=Yes;
	|Data Source=" + КаталогИБ() + ";
	|Mode=ReadWrite;
	|Mask Password=False;
	|Collating Sequence=RUSSIAN;
	//|OLE DB Services=0;
	|";

	лРезультатСоединения = OLEDBData.Соединение(СтрокаПодключения);
	Сам().ПроверитьРавенство(лРезультатСоединения, 1);

	OLEDBCommand = OLEDBData.СоздатьКоманду();

	Возврат OLEDBCommand;
КонецФункции // СоздатьИСоединить()

//_____________________________________________________________________________
//
Функция УдалитьРазделитель(Путь)
	Возврат ?(Прав(Путь, 1) <> "\", Путь, Лев(Путь, СтрДлина(Путь)-1));
КонецФункции // УдалитьРазделитель()

//_____________________________________________________________________________
//
Функция ЭтоКаталог(ИмяФайла)
	ИмяФайла = УдалитьРазделитель(ИмяФайла);
	П = ""; 	АтрибутыФайла = "";
	ФС.АтрибутыФайла(ИмяФайла, П, АтрибутыФайла, П, П, П, П);
	Если Сред(АтрибутыФайла, 4, 1)="1"  Тогда // каталог
		Возврат 1;
	КонецЕсли;
	Возврат 0;
КонецФункции // ЭтоКаталог()

//_____________________________________________________________________________
//
Процедура СоздатьКаталог(ИмяКаталога)
	Если ФС.СуществуетФайл(ИмяКаталога) = 0 Тогда
		ФС.СоздатьКаталог(ИмяКаталога);
		//Сообщить("каталог <"+ИмяКаталога+"> создан!");
	КонецЕсли;
КонецПроцедуры // СоздатьКаталог()

//_____________________________________________________________________________
//
Процедура Деструктор()
	Попытка
		OLEDBCommand.Закрыть();
	Исключение
	КонецПопытки;

	OLEDBCommand = 0;
	Попытка
		OLEDBData.Закрыть();
	Исключение
	КонецПопытки;

	Если СокрЛП(ИмяКаталогаВременныхФайлов) <> "" Тогда

		Если ЭтоКаталог(ИмяКаталогаВременныхФайлов) = 1 Тогда
			//Сообщить("удаляю ИмяКаталогаВременныхФайлов = <"+ИмяКаталогаВременныхФайлов+">");
			ФС.УдалитьКаталог(ИмяКаталогаВременныхФайлов);
		КонецЕсли;
	КонецЕсли;

КонецПроцедуры // Деструктор()

//_____________________________________________________________________________
//
Процедура Тест_OLEDBData_СоздатьОбъект() Экспорт
	OLEDBData = OLEDBData();
	Сам().ПроверитьРавенство(ТипЗначенияСтр(OLEDBData), "OLEDBData");
КонецПроцедуры // Тест_OLEDBData_СоздатьОбъект()

//_____________________________________________________________________________
//
Процедура Тест_OLEDBData_Соединение() Экспорт
	OLEDBData_СоздатьИСоединить();
КонецПроцедуры // Тест_OLEDBData_Соединение()

//_____________________________________________________________________________
//
Процедура Тест_OLEDBData_СоединениеСОшибкой() Экспорт
	OLEDBData = OLEDBData();

	СтрокаПодключения =
	"Provider=НеверныйVFPOLEDB.1;
	|Deleted=Yes;
	|Data Source=" + КаталогИБ() + ";
	|Mode=ReadWrite;
	|Mask Password=False;
	|Collating Sequence=RUSSIAN;
	//|OLE DB Services=0;
	|";
	
	Сам().ПроверитьИсключение(OLEDBData, "Соединение", СтрокаПодключения);

	СтрокаПодключения =
	"Provider=VFPOLEDB.1;
	|Deleted=Yes;
	|Data Source=" + "!ОШИБКА!" + КаталогИБ() + ";
	|Mode=ReadWrite;
	|Mask Password=False;
	|Collating Sequence=RUSSIAN;
	//|OLE DB Services=0;
	|";
	
	Сам().ПроверитьИсключение(OLEDBData, "Соединение", СтрокаПодключения);
КонецПроцедуры // Тест_OLEDBData_СоединениеСОшибкой()

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

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

//_____________________________________________________________________________
//
Процедура Тест_OLEDBData_СоздатьКомандуБезСоединения() Экспорт
	OLEDBData = OLEDBData();
	Сам().ПроверитьИсключение(OLEDBData, "СоздатьКоманду"); // Объект.СоздатьКоманду();
КонецПроцедуры // Тест_OLEDBData_СоздатьКомандуБезСоединения()

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

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

//_____________________________________________________________________________
//
Процедура Тест_OLEDBCommand_Создать() Экспорт
	фМожноСоздатьOLEDBCommand = 1;
	Попытка
		СоздатьОбъект("OLEDBCommand");
	Исключение
		фМожноСоздатьOLEDBCommand = 0;
	КонецПопытки;
	
	Сам().ПроверитьРавенство(фМожноСоздатьOLEDBCommand, 0);
КонецПроцедуры // Тест_OLEDBCommand_Создать()

//_____________________________________________________________________________
//
Процедура Тест_OLEDBCommand_Отладка() Экспорт
	OLEDBCommand = СоздатьИСоединить();
	OLEDBCommand.Отладка(1);
	OLEDBCommand.Отладка(0);
КонецПроцедуры // Тест_OLEDBCommand_Отладка()

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

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

	ТекстЗапроса =
	"select *
	|from 1SUSERS.DBF";
	
	Сам().ПроверитьИсключение(OLEDBCommand, "Выполнить", ТекстЗапроса);
КонецПроцедуры // Тест_OLEDBCommand_ВыполнитьПослеЗакрытия()

//_____________________________________________________________________________
//
Процедура Тест_OLEDBCommand_ВыполнитьИнструкциюПослеЗакрытия() Экспорт
	OLEDBCommand = СоздатьИСоединить();
	OLEDBCommand.Закрыть();

	ТекстЗапроса =
	"select *
	|from 1SUSERS.DBF";
	
	Сам().ПроверитьИсключение(OLEDBCommand, "ВыполнитьИнструкцию", ТекстЗапроса);
КонецПроцедуры // Тест_OLEDBCommand_ВыполнитьИнструкциюПослеЗакрытия()

//_____________________________________________________________________________
//
Процедура Тест_OLEDBCommand_ВыполнитьПослеЗакрытияOLEDBData() Экспорт
	OLEDBCommand = СоздатьИСоединить();
	OLEDBData.Закрыть();

	ТекстЗапроса =
	"select *
	|from 1SUSERS.DBF";

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

//_____________________________________________________________________________
//
Процедура Тест_OLEDBCommand_ВыполнитьИнструкциюПослеЗакрытияOLEDBData() //Экспорт
	OLEDBCommand = СоздатьИСоединить();
	OLEDBData.Закрыть();

	ТекстЗапроса =
	"select *
	|from 1SUSERS.DBF";

	лТабЗапроса = OLEDBCommand.ВыполнитьИнструкцию(ТекстЗапроса);
	Сам().ПроверитьРавенство(ТипЗначенияСтр(лТабЗапроса), "ТаблицаЗначений");

	Сам().ПроверитьРавенство(лТабЗапроса.КоличествоСтрок(), 1);
	лТабЗапроса.ПолучитьСтрокуПоНомеру(1);
	Сам().ПроверитьБольшеИлиРавно(лТабЗапроса.USRSCNT, 1);
	Сам().ПроверитьБольшеИлиРавно(лТабЗапроса.NETCHGCN, 0);
КонецПроцедуры // Тест_OLEDBCommand_ВыполнитьИнструкциюПослеЗакрытияOLEDBData()

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

	ТекстЗапроса =
	"select *
	|from 1SUSERS.DBF";
	лКоличество = OLEDBCommand.Выполнить(ТекстЗапроса);
	Сам().ПроверитьРавенство(лКоличество, 1);
КонецПроцедуры // Тест_OLEDBCommand_Выполнить()

//_____________________________________________________________________________
//
Процедура Тест_OLEDBCommand_Выполнить_CREATE_TABLE() Экспорт
	OLEDBCommand = СоздатьИСоединить();
	ИмяФайла = "1cpp156";

	ТекстЗапроса =
	"
	|CREATE TABLE "+ИмяФайла+" (ISFOLDER N(1,0))
	|";
	лКоличество = OLEDBCommand.Выполнить(ТекстЗапроса);

	Если ФС.СуществуетФайл(КаталогИБ()+ИмяФайла+".DBF") = 1 Тогда
		ФС.УдалитьФайл(КаталогИБ()+ИмяФайла+".DBF");
	КонецЕсли;

	Сам().ПроверитьРавенство(лКоличество, -1);
КонецПроцедуры // Тест_OLEDBCommand_Выполнить_CREATE_TABLE()

//_____________________________________________________________________________
//
Процедура Тест_OLEDBCommand_Выполнить_DROP_TABLE() Экспорт
	OLEDBCommand = СоздатьИСоединить();
	ИмяФайла = "1cpp156";

	ТекстЗапроса =
	"
	|CREATE TABLE "+ИмяФайла+" (ISFOLDER N(1,0))
	|";
	OLEDBCommand.Выполнить(ТекстЗапроса);

	ТекстЗапроса =
	"
	| DROP TABLE "+ИмяФайла+"
	|";
	лКоличество = OLEDBCommand.Выполнить(ТекстЗапроса);

	Если ФС.СуществуетФайл(КаталогИБ()+ИмяФайла+".DBF") = 1 Тогда
		ФС.УдалитьФайл(КаталогИБ()+ИмяФайла+".DBF");
	КонецЕсли;

	Сам().ПроверитьРавенство(лКоличество, -1);
КонецПроцедуры // Тест_OLEDBCommand_Выполнить_DROP_TABLE()

//_____________________________________________________________________________
//
Процедура Тест_OLEDBCommand_Выполнить_НесколькоЗапросов() Экспорт
	OLEDBCommand = СоздатьИСоединить();
	ИмяФайла = "1cpp156";

	ТекстЗапроса =
	"
	|CREATE TABLE "+ИмяФайла+" (ISFOLDER N(1,0))
	|
	| DROP TABLE "+ИмяФайла+"
	|";
	Сам().ПроверитьИсключение(OLEDBCommand, "Выполнить", ТекстЗапроса);
КонецПроцедуры // Тест_OLEDBCommand_Выполнить_НесколькоЗапросов()

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

	ТекстЗапроса =
	"select *
	|from 11SUSERS.DBF"; // неверный файл

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

//_____________________________________________________________________________
//
Процедура Тест_OLEDBCommand_ВыполнитьИнструкцию() Экспорт
	OLEDBCommand = СоздатьИСоединить();

	ТекстЗапроса =
	"select *
	|from 1SUSERS.DBF";
	лТабЗапроса = OLEDBCommand.ВыполнитьИнструкцию(ТекстЗапроса);
	Сам().ПроверитьРавенство(ТипЗначенияСтр(лТабЗапроса), "ТаблицаЗначений");

	Сам().ПроверитьРавенство(лТабЗапроса.КоличествоСтрок(), 1);
	лТабЗапроса.ПолучитьСтрокуПоНомеру(1);
	Сам().ПроверитьБольшеИлиРавно(лТабЗапроса.USRSCNT, 1);
	Сам().ПроверитьБольшеИлиРавно(лТабЗапроса.NETCHGCN, 0);
КонецПроцедуры // Тест_OLEDBCommand_ВыполнитьИнструкцию()

//_____________________________________________________________________________
//
Процедура Тест_OLEDBCommand_ВыполнитьИнструкцию_НеверныйЗапрос1() Экспорт
	OLEDBCommand = СоздатьИСоединить();

	ТекстЗапроса =
	"select *
	|from 11SUSERS.DBF"; // неверный файл

	Сам().ПроверитьИсключение(OLEDBCommand, "ВыполнитьИнструкцию", ТекстЗапроса); //OLEDBCommand.Выполнить(ТекстЗапроса);

	ТекстЗапроса =
	"select *
	|from :ИмяФайла"; // файл не будет указан

	Сам().ПроверитьИсключение(OLEDBCommand, "ВыполнитьИнструкцию", ТекстЗапроса); //OLEDBCommand.Выполнить(ТекстЗапроса);

	// несколько выражений в одном запросе
	ИмяФайла = "1cpp156";
	ТекстЗапроса =
	"
	|select *
	|from 1SUSERS.DBF
	|
	|  CREATE TABLE "+ИмяФайла+" (ISFOLDER N(1,0))
	|
	|  DROP TABLE "+ИмяФайла+"
	|";

	Сам().ПроверитьИсключение(OLEDBCommand, "ВыполнитьИнструкцию", ТекстЗапроса); //OLEDBCommand.Выполнить(ТекстЗапроса);

	// несколько выражений в одном запросе
	ТекстЗапроса =
	"
	|  CREATE TABLE "+ИмяФайла+" (ISFOLDER N(1,0))
	|
	|  DROP TABLE "+ИмяФайла+"
	|
	|  select *
	|from 1SUSERS.DBF
	|";

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

//_____________________________________________________________________________
//
Процедура Тест_OLEDBCommand_УстановитьТекстовыйПараметр() Экспорт
	OLEDBCommand = СоздатьИСоединить();

	ТекстЗапроса =
	"select *
	|from :ИмяФайла";

	ТекстЗапросаКопия =
	"select *
	|from :ИмяФайла";

	OLEDBCommand.УстановитьТекстовыйПараметр("ИмяФайла", "11SUSERS.DBF");
	OLEDBCommand.УстановитьТекстовыйПараметр("ИмяФайла", "1SUSERS.DBF");

	Сам().ПроверитьРавенство(ТекстЗапроса, ТекстЗапросаКопия); // убедимся, что исходная строка не меняется

	лТабЗапроса = OLEDBCommand.ВыполнитьИнструкцию(ТекстЗапроса);
	Сам().ПроверитьРавенство(ТипЗначенияСтр(лТабЗапроса), "ТаблицаЗначений");

	Сам().ПроверитьРавенство(лТабЗапроса.КоличествоСтрок(), 1);
	лТабЗапроса.ПолучитьСтрокуПоНомеру(1);
	Сам().ПроверитьБольшеИлиРавно(лТабЗапроса.USRSCNT, 1);
	Сам().ПроверитьБольшеИлиРавно(лТабЗапроса.NETCHGCN, 0);

КонецПроцедуры // Тест_OLEDBCommand_УстановитьТекстовыйПараметр()

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

	ТекстЗапроса =
	"select *
	|from :ИмяФайла";

	OLEDBCommand.УстановитьТекстовыйПараметр("ИмяФайла", "1SUSERS.DBF");
	лТабЗапроса = OLEDBCommand.ВыполнитьИнструкцию(ТекстЗапроса);

	// TODO правильно ли выдается исключение или удобнее использовать предыдущую установку параметра ??
	//лТабЗапроса = OLEDBCommand.ВыполнитьИнструкцию(ТекстЗапроса);
	// если неправильно, включить след.строку
	Сам().ПроверитьИсключение(OLEDBCommand, "ВыполнитьИнструкцию", ТекстЗапроса);
КонецПроцедуры // Тест_OLEDBCommand_Выполнить_БезПовтораУстановитьТекстовыйПараметр()

//_____________________________________________________________________________
//
Процедура Тест_OLEDBCommand_УстановитьТекстовыйПараметр_КоторыйНесуществует() Экспорт
	OLEDBCommand = СоздатьИСоединить();

	// TODO сейчас никаких ошибок при выполнении запроса, уточнить нужна ли ошибка :(
	OLEDBCommand.УстановитьТекстовыйПараметр("НесуществующийПараметр", "НенужноеДанное");

	ТекстЗапроса =
	"select *
	|from :ИмяФайла";

	OLEDBCommand.УстановитьТекстовыйПараметр("ИмяФайла", "1SUSERS.DBF");
	лТабЗапроса = OLEDBCommand.ВыполнитьИнструкцию(ТекстЗапроса);
КонецПроцедуры // Тест_OLEDBCommand_УстановитьТекстовыйПараметр_КоторыйНесуществует()

//_____________________________________________________________________________
//
Процедура Тест_OLEDBCommand_УстановитьТекстовыйПараметр_НеверныеПараметры() Экспорт
	OLEDBCommand = СоздатьИСоединить();

	// TODO сейчас никаких ошибок при выполнении :(
	OLEDBCommand.УстановитьТекстовыйПараметр("НесуществующийПараметр", "НенужноеДанное");

	ТекстЗапроса =
	"select *
	|from :ИмяФайла";

	OLEDBCommand.УстановитьТекстовыйПараметр("ИмяФайла", "11SUSERS.DBF");
	Сам().ПроверитьИсключение(OLEDBCommand, "ВыполнитьИнструкцию", ТекстЗапроса); //OLEDBCommand.Выполнить(ТекстЗапроса);

	OLEDBCommand.УстановитьТекстовыйПараметр("ИмяФайла", 0); // число
	Сам().ПроверитьИсключение(OLEDBCommand, "ВыполнитьИнструкцию", ТекстЗапроса); //OLEDBCommand.Выполнить(ТекстЗапроса);

КонецПроцедуры // Тест_OLEDBCommand_УстановитьТекстовыйПараметр_НеверныеПараметры()

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

	OLEDBCommand.УстановитьКаталогВремТаблиц("C:");
	OLEDBCommand.УстановитьКаталогВремТаблиц("C:\");

	Сам().ПроверитьИсключение(OLEDBCommand, "УстановитьКаталогВремТаблиц", ""); // пустая строка

	ИмяКаталогаСПробелами = КаталогИБ()+"Каталог Временных Файлов";
	Сам().ПроверитьИсключение(OLEDBCommand, "УстановитьКаталогВремТаблиц", ИмяКаталогаСПробелами); // проверю пробелы

	ИмяКаталогаСПробелами = КаталогИБ()+"Temp files folder";
	Сам().ПроверитьИсключение(OLEDBCommand, "УстановитьКаталогВремТаблиц", ИмяКаталогаСПробелами); // проверю пробелы
КонецПроцедуры // Тест_OLEDBCommand_УстановитьКаталогВремТаблиц_НеверныеПараметры()

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

	ИмяКаталога = "КаталогВременныхФайлов";
	//ИмяКаталога = "TempFilesFolder";
	ИмяКаталогаВременныхФайлов = КаталогИБ()+ИмяКаталога;

	Если Найти(ИмяКаталогаВременныхФайлов, " ") > 0 Тогда // пробелы есть ?
		ИмяКаталогаВременныхФайлов = "C:\"+ИмяКаталога;
	КонецЕсли;

	СоздатьКаталог(ИмяКаталогаВременныхФайлов);
	OLEDBCommand.УстановитьКаталогВремТаблиц(ИмяКаталогаВременныхФайлов);

	ИмяКаталогаВременныхФайлов = ИмяКаталогаВременныхФайлов + "\";
	OLEDBCommand.УстановитьКаталогВремТаблиц(ИмяКаталогаВременныхФайлов);
КонецПроцедуры // Тест_OLEDBCommand_УстановитьКаталогВремТаблиц()

//_____________________________________________________________________________
//
Функция ПроверитьУложитьСписокОбъектов_Начало()
	OLEDBCommand = СоздатьИСоединить();

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

//_____________________________________________________________________________
//
Функция ПроверитьУложитьСписокОбъектов_Конец(СписокДокументов)
	ИмяТаблицы = "";
	OLEDBCommand.УложитьСписокОбъектов(СписокДокументов, ИмяТаблицы);

	ИмяФайлаТаблицы = ИмяТаблицы+".dbf";

	// проверю созданный дбф-файл
	Сам().ПроверитьНеРавенство(ИмяТаблицы, "");
	Сам().ПроверитьРавенство(ФС.СуществуетФайл(ИмяФайлаТаблицы), 1);

	// т.к. ДБФ не работает с длинными именами файлов, создаю файл с коротким именем
	ИмяФайлаТаблицы2 = "C:\1cpptemp.dbf";
	Если ФС.СуществуетФайл(ИмяФайлаТаблицы2) = 1 Тогда
		ФС.УдалитьФайл(ИмяФайлаТаблицы2);
		Если ФС.СуществуетФайл(ИмяФайлаТаблицы2) = 1 Тогда
			Модуль = СоздатьОбъект("ВыполняемыйМодуль");
			Модуль.ВыброситьИскл(, "Не удалось удалить файл "+ИмяФайлаТаблицы2);
		КонецЕсли;
	КонецЕсли;
	ФС.КопироватьФайл(ИмяФайлаТаблицы, ИмяФайлаТаблицы2, 1);

	ДБФФайл = СоздатьОбъект("XBase");
	ДБФФайл.ОткрытьФайл(ИмяФайлаТаблицы2,, 1); // только чтение
	Сам().ПроверитьРавенство(ДБФФайл.Открыта(), 1);

	Сам().ПроверитьРавенство(ДБФФайл.КоличествоЗаписей(), СписокДокументов.РазмерСписка());
	Сам().ПроверитьБольшеИлиРавно(ДБФФайл.КоличествоПолей(), 2); // на самом деле 3 поля

	// теперь проверю тип полей
		//VAL         Character          9
		//ISFOLDER    Numeric            2       0

	НаименованиеПоля = "";
	ТипПоля = "";
	ДлинаПоля = 0;
	ТочностьПоля = 0;
	ДБФФайл.ОписаниеПоля(1, НаименованиеПоля, ТипПоля, ДлинаПоля, ТочностьПоля);
	Сам().ПроверитьРавенство(НаименованиеПоля, "VAL");
	Сам().ПроверитьРавенство(ТипПоля, 2);
	Сам().ПроверитьРавенство(ДлинаПоля, 9);

	НаименованиеПоля = "";
	ТипПоля = "";
	ДлинаПоля = 0;
	ТочностьПоля = -1;
	ДБФФайл.ОписаниеПоля(2, НаименованиеПоля, ТипПоля, ДлинаПоля, ТочностьПоля);
	Сам().ПроверитьРавенство(НаименованиеПоля, "ISFOLDER");
	Сам().ПроверитьРавенство(ТипПоля, 1);
	Сам().ПроверитьРавенство(ДлинаПоля, 2);
	Сам().ПроверитьРавенство(ТочностьПоля, 0);

	// теперь проверю сами значения полей
	MetaDataWork = СоздатьОбъект("MetaDataWork");
	Для к=1 По ДБФФайл.КоличествоЗаписей() Цикл
		ДБФФайл.Перейти(к);
		ИДИзБазы = ДБФФайл.VAL;

		ИДДокумента = MetaDataWork.ЗначениеВСтрокуБД(СписокДокументов.ПолучитьЗначение(к));
		Сам().ПроверитьРавенство(ИДИзБазы, ИДДокумента);

		Сам().ПроверитьРавенство(ДБФФайл.IsFolder, 2);
	КонецЦикла;

	ДБФФайл.ЗакрытьФайл();

	//// теперь проверю удаление временной таблицы
	//OLEDBCommand = 0;
	//Сам().ПроверитьРавенство(ФС.СуществуетФайл(ИмяФайлаТаблицы), 0);

	Возврат ИмяФайлаТаблицы;
КонецФункции // ПроверитьУложитьСписокОбъектов_Конец()

//_____________________________________________________________________________
//
Процедура Тест_OLEDBCommand_УложитьСписокОбъектов_ВКаталогИБ_Список() Экспорт

	//Если Найти(КаталогИБ(), " ") > 0 Тогда // пробелы есть ?
	//	Сам().ПропуститьТест(0, "Для проверки этого теста в наименовании каталога ИБ не должно быть пробелов");
	//КонецЕсли;

	СписокДокументов = ПроверитьУложитьСписокОбъектов_Начало();
	ИмяФайлаТаблицы = ПроверитьУложитьСписокОбъектов_Конец(СписокДокументов);

	// проверю созданный дбф-файл
	Сам().ПроверитьНеРавенство(ИмяФайлаТаблицы, "");
	Сам().ПроверитьРавенство(ФС.СуществуетФайл(КаталогИБ()+ИмяФайлаТаблицы), 1);

КонецПроцедуры // Тест_OLEDBCommand_УложитьСписокОбъектов_ВКаталогИБ_Список()

//_____________________________________________________________________________
//
Процедура Тест_OLEDBCommand_УложитьСписокОбъектов_ВДругойКаталог_Список() Экспорт
	СписокДокументов = ПроверитьУложитьСписокОбъектов_Начало();

	Тест_OLEDBCommand_УстановитьКаталогВремТаблиц();

	ПроверитьУложитьСписокОбъектов_Конец(СписокДокументов);
КонецПроцедуры // Тест_OLEDBCommand_УложитьСписокОбъектов_ВДругойКаталог_Список()

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

	ИмяКаталогаВременныхФайлов = "C:\"+"КаталогВременныхФайлов";
	//ИмяКаталогаВременныхФайлов = "C:\"+"TempFilesFolder";
	СоздатьКаталог(ИмяКаталогаВременныхФайлов);

	OLEDBCommand.УстановитьКаталогВремТаблиц(ИмяКаталогаВременныхФайлов);

	// несколько раз
	ИмяТаблицы1 = "";
	OLEDBCommand.УложитьСписокОбъектов(СписокДокументов, ИмяТаблицы1);

	ИмяТаблицы2 = "";
	OLEDBCommand.УложитьСписокОбъектов(СписокДокументов, ИмяТаблицы2);

	ИмяТаблицы3 = "";
	OLEDBCommand.УложитьСписокОбъектов(СписокДокументов, ИмяТаблицы3);

	Сам().ПроверитьНеРавенство(ИмяТаблицы1, ИмяТаблицы2);
	Сам().ПроверитьНеРавенство(ИмяТаблицы1, ИмяТаблицы3);
	Сам().ПроверитьНеРавенство(ИмяТаблицы2, ИмяТаблицы3);

	Сам().ПроверитьРавенство(ФС.СуществуетФайл(ИмяТаблицы1+".dbf"), 1);
	Сам().ПроверитьРавенство(ФС.СуществуетФайл(ИмяТаблицы2+".dbf"), 1);
	Сам().ПроверитьРавенство(ФС.СуществуетФайл(ИмяТаблицы3+".dbf"), 1);

	// теперь проверю удаление временной таблицы
	OLEDBCommand = 0;
	Сам().ПроверитьРавенство(ФС.СуществуетФайл(ИмяТаблицы1+".dbf"), 0);
	Сам().ПроверитьРавенство(ФС.СуществуетФайл(ИмяТаблицы2+".dbf"), 0);
	Сам().ПроверитьРавенство(ФС.СуществуетФайл(ИмяТаблицы3+".dbf"), 0);
КонецПроцедуры // Тест_OLEDBCommand_УложитьСписокОбъектов_УдалениеВременныхФайлов_ВДеструкторе()

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

	ИмяКаталогаВременныхФайлов = "C:\"+"КаталогВременныхФайлов";
	//ИмяКаталогаВременныхФайлов = "C:\"+"TempFilesFolder";
	СоздатьКаталог(ИмяКаталогаВременныхФайлов);

	OLEDBCommand.УстановитьКаталогВремТаблиц(ИмяКаталогаВременныхФайлов);

	// несколько раз
	ИмяТаблицы1 = "";
	OLEDBCommand.УложитьСписокОбъектов(СписокДокументов, ИмяТаблицы1);

	ИмяТаблицы2 = "";
	OLEDBCommand.УложитьСписокОбъектов(СписокДокументов, ИмяТаблицы2);

	ИмяТаблицы3 = "";
	OLEDBCommand.УложитьСписокОбъектов(СписокДокументов, ИмяТаблицы3);

	Сам().ПроверитьНеРавенство(ИмяТаблицы1, ИмяТаблицы2);
	Сам().ПроверитьНеРавенство(ИмяТаблицы1, ИмяТаблицы3);
	Сам().ПроверитьНеРавенство(ИмяТаблицы2, ИмяТаблицы3);

	Сам().ПроверитьРавенство(ФС.СуществуетФайл(ИмяТаблицы1+".dbf"), 1);
	Сам().ПроверитьРавенство(ФС.СуществуетФайл(ИмяТаблицы2+".dbf"), 1);
	Сам().ПроверитьРавенство(ФС.СуществуетФайл(ИмяТаблицы3+".dbf"), 1);

	// теперь проверю удаление временной таблицы
	OLEDBCommand.Закрыть();
	Сам().ПроверитьРавенство(ФС.СуществуетФайл(ИмяТаблицы1+".dbf"), 0);
	Сам().ПроверитьРавенство(ФС.СуществуетФайл(ИмяТаблицы2+".dbf"), 0);
	Сам().ПроверитьРавенство(ФС.СуществуетФайл(ИмяТаблицы3+".dbf"), 0);
КонецПроцедуры // Тест_OLEDBCommand_УложитьСписокОбъектов_УдалениеВременныхФайлов_ПриЗакрытии()

//_____________________________________________________________________________
//
Процедура Тест_OLEDBData_СоединениеПоУмолчанию() Экспорт
	Сам().ПропуститьТест(, "не согласованный функционал");
	
	OLEDBData = OLEDBData();

	лРезультатСоединения = OLEDBData.Соединение();
	Сам().ПроверитьРавенство(лРезультатСоединения, 1);

	OLEDBCommand = OLEDBData.СоздатьКоманду();

	ТекстЗапроса =
	"select *
	|from 1SUSERS.DBF";
	лКоличество = OLEDBCommand.Выполнить(ТекстЗапроса);
	Сам().ПроверитьРавенство(лКоличество, 1);
КонецПроцедуры // Тест_OLEDBData_СоединениеПоУмолчанию()

//_____________________________________________________________________________
//
Процедура Тест_OLEDBCommand_СоединениеПоУмолчанию2() Экспорт
	Сам().ПропуститьТест(, "не согласованный функционал");
	
	OLEDBData = OLEDBData();

	лРезультатСоединения = OLEDBData.Соединение();
	Сам().ПроверитьРавенство(лРезультатСоединения, 1);

	OLEDBCommand = OLEDBData.СоздатьКоманду();

	ТекстЗапроса =
	"select *
	|from 1SUSERS.DBF";
	лТабЗапроса = OLEDBCommand.ВыполнитьИнструкцию(ТекстЗапроса);
	Сам().ПроверитьРавенство(ТипЗначенияСтр(лТабЗапроса), "ТаблицаЗначений");

	Сам().ПроверитьРавенство(лТабЗапроса.КоличествоСтрок(), 1);
	лТабЗапроса.ПолучитьСтрокуПоНомеру(1);
	Сам().ПроверитьБольшеИлиРавно(лТабЗапроса.USRSCNT, 1);
	Сам().ПроверитьБольшеИлиРавно(лТабЗапроса.NETCHGCN, 0);

КонецПроцедуры // Тест_OLEDBCommand_СоединениеПоУмолчанию2()

//_____________________________________________________________________________
//
Процедура Тест_OLEDBData_Парам_Строка() Экспорт
	Перем cmd;
	Перем тЗапрос;
	Перем ТЗэт, ТЗ;
	Перем ТекИД, ТекНаим;
	
	//Сам().ПропуститьТест(, "новый функционал, еще не реализован в репозитарии");
	
	cmd = СоздатьИСоединить();
	cmd.Отладка(0);

	// получаем таблицу с id and descr
	//
	тЗапрос = "
	|SELECT
	|	id,
	|	descr
	|FROM
	|	$Справочник.Классы1СПП 
	|ORDER BY 
	|	id, descr 
	|";

	ТЗэт = cmd.ExecuteStatement(тЗапрос);

	cmd.ДобПараметр(1, 129, 9, 0, "");
	cmd.ДобПараметр(1, 129, 100, 0, "");

	тЗапрос = "
	|SELECT
	|	id,
	|	descr
	|FROM
	|	$Справочник.Классы1СПП
	|WHERE 
	|	(id = ?) AND (descr = ?) 
	|ORDER BY 
	|	id, descr 
	|";
	
	cmd.Подготовить(тЗапрос);

	Для П = 1 По ТЗэт.КоличествоСтрок() Цикл
		ТекИД	 = ТЗэт.ПолучитьЗначение(П, "id");
		ТекНаим	 = ТЗэт.ПолучитьЗначение(П, "descr");

		cmd.УстановитьПараметр(1, ТекИД);
		cmd.УстановитьПараметр(2, ТекНаим);

		ТЗ = cmd.ExecuteStatement();

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

		Состояние("Обработано строк: " + П);
	КонецЦикла;
	
	cmd.Unprepare();
	cmd.Закрыть();
КонецПроцедуры // Тест_OLEDBData_Парам_Строка()

//_____________________________________________________________________________
//
Процедура Тест_OLEDBData_Парам_Спр9() Экспорт
	Перем cmd;
	Перем тЗапрос;
	Перем ТЗэт, ТЗ;
	Перем ТекИД, РезИД;
	
	//Сам().ПропуститьТест(, "новый функционал, еще не реализован в репозитарии");
	
	cmd = СоздатьИСоединить();
	
	тЗапрос = "
	|SELECT 
	|	id as [obj $Справочник.Классы1СПП], 
	|	descr 
	|FROM 
	|	$Справочник.Классы1СПП 
	|ORDER BY 
	|	id, descr 
	|";
	
	ТЗэт = cmd.ExecuteStatement(тЗапрос);
	
	// Должна быть ТЗ и хоть одна строка для прогона теста
	//
	Сам().ПроверитьРавенство(ТипЗначенияСтр(ТЗэт), "ТаблицаЗначений");
	Сам().ПроверитьБольшеИлиРавно(ТЗэт.КоличествоСтрок(), 1);
	
	cmd.ДобПараметр(1, 129, 9, 0, "");
	
	тЗапрос = "
	|SELECT 
	|	id as [obj $Справочник.Классы1СПП], 
	|	descr 
	|FROM 
	|	$Справочник.Классы1СПП 
	|WHERE 
	|	(id = ?) 
	|ORDER BY 
	|	id, descr 
	|";
	
	cmd.Подготовить(тЗапрос);
	
	Для П = 1 По ТЗэт.КоличествоСтрок() Цикл
		ТекИД = ТЗэт.ПолучитьЗначение(П, "obj");
		
		cmd.УстановитьПараметр(1, ТекИД);
		
		ТЗ = cmd.ExecuteStatement();
		
		Сам().ПроверитьРавенство(ТипЗначенияСтр(ТЗ), "ТаблицаЗначений");
		Сам().ПроверитьРавенство(ТЗ.КоличествоСтрок(), 1);
		
		РезИД = ТЗ.ПолучитьЗначение(1, "obj");
		
		Сам().ПроверитьРавенство(ТекИД, РезИД);
		
		Состояние("Обработано строк: " + П);
	КонецЦикла;
	
	cmd.Unprepare();
	cmd.Закрыть();
КонецПроцедуры // Тест_OLEDBData_Парам_Спр9()

//_____________________________________________________________________________
//
Процедура Тест_OLEDBData_Парам_Док9_Строка4() Экспорт
	Перем cmd;
	Перем ТЗэт, ТЗ;
	Перем ТекИД, ТекИДФ;
	Перем РезИД, РезИДФ;
	
	//Сам().ПропуститьТест(, "новый функционал, еще не реализован в репозитарии");
	
	cmd = СоздатьИСоединить();
	
	тЗапрос = "
	|SELECT 
	|	jrn.iddoc as [Doc $Документ], 
	|	jrn.iddocdef as Doc_kind 
	|FROM 
	|	[1SJOURN] as jrn 
	|WHERE 
	|	jrn.iddocdef = $ВидДокумента36.Новый1 
	|ORDER BY 
	|	jrn.iddoc, jrn.iddocdef 
	|";
	
	ТЗэт = cmd.ExecuteStatement(тЗапрос);
	
	// Должна быть ТЗ и хоть одна строка для прогона теста
	//
	Сам().ПроверитьРавенство(ТипЗначенияСтр(ТЗэт), "ТаблицаЗначений");
	Сам().ПроверитьБольшеИлиРавно(ТЗэт.КоличествоСтрок(), 1);
	
	cmd.ДобПараметр(1, 129, 9, 0, ""); // iddoc
	cmd.ДобПараметр(1, 129, 4, 0, ""); // iddocdef
	
	тЗапрос = "
	|SELECT 
	|	jrn.iddoc as [Doc $Документ], 
	|	jrn.iddocdef as Doc_kind 
	|FROM 
	|	[1SJOURN] as jrn 
	|WHERE 
	|	(jrn.iddoc = ?) AND (jrn.iddocdef = ?) 
	|ORDER BY 
	|	jrn.iddoc, jrn.iddocdef 
	|";
	
	cmd.Подготовить(тЗапрос);
	
	Для П = 1 По ТЗэт.КоличествоСтрок() Цикл
		ТекИД	 = ТЗэт.ПолучитьЗначение(П, "Doc");
		ТекИДФ	 = ТЗэт.ПолучитьЗначение(П, "Doc_kind");
		
		cmd.УстановитьПараметр(1, ТекИД); // iddoc
		cmd.УстановитьПараметр(2, ТекИДФ); // iddocdef
		
		ТЗ = cmd.ExecuteStatement();
		
		Сам().ПроверитьРавенство(ТипЗначенияСтр(ТЗ), "ТаблицаЗначений");
		Сам().ПроверитьРавенство(ТЗ.КоличествоСтрок(), 1);
		
		РезИД	 = ТЗ.ПолучитьЗначение(1, "Doc");
		РезИДФ	 = ТЗ.ПолучитьЗначение(1, "Doc_kind");
		
		Сам().ПроверитьРавенство(ТекИД, РезИД);
		Сам().ПроверитьРавенство(ТекИДФ, РезИДФ);
		
		Состояние("Обработано строк: " + П);
	КонецЦикла;
	
	cmd.Unprepare();
	cmd.Закрыть();
КонецПроцедуры // Тест_OLEDBData_Парам_Док9_Строка4()

//_____________________________________________________________________________
//
Процедура Тест_OLEDBData_Парам_Док9_Дата() Экспорт
	Перем cmd;
	Перем тЗапрос;
	Перем ТЗэт, ТЗ;
	Перем ТекИД, ТекДат;
	Перем РезИД, РезДат;
	
	//Сам().ПропуститьТест(, "новый функционал, еще не реализован в репозитарии");
	
	cmd = СоздатьИСоединить();
	
	тЗапрос = "
	|SELECT 
	|	jrn.iddoc as doc_id, 
	|	jrn.date as doc_date 
	|FROM 
	|	[1SJOURN] as jrn 
	|ORDER BY 
	|	jrn.iddoc, jrn.date 
	|";
	
	ТЗэт = cmd.ExecuteStatement(тЗапрос);
	
	// Должна быть ТЗ и хоть одна строка для прогона теста
	//
	Сам().ПроверитьРавенство(ТипЗначенияСтр(ТЗэт), "ТаблицаЗначений");
	Сам().ПроверитьБольшеИлиРавно(ТЗэт.КоличествоСтрок(), 1);
	
	cmd.ДобПараметр(1, 129, 9, 0, "");
	cmd.ДобПараметр(1, 133, 8, 0, "");
	
	тЗапрос = "
	|SELECT 
	|	jrn.iddoc as doc_id, 
	|	jrn.date as doc_date 
	|FROM 
	|	[1SJOURN] as jrn 
	|WHERE 
	|	(jrn.iddoc = ?) AND (jrn.date = ?) 
	|ORDER BY 
	|	jrn.iddoc, jrn.date 
	|";
	
	cmd.Подготовить(тЗапрос);
	
	Для П = 1 По ТЗэт.КоличествоСтрок() Цикл
		ТекИД	 = ТЗэт.ПолучитьЗначение(П, "doc_id");
		ТекДат	 = ТЗэт.ПолучитьЗначение(П, "doc_date");
		
		cmd.УстановитьПараметр(1, ТекИД);
		cmd.УстановитьПараметр(2, ТекДат);
		
		ТЗ = cmd.ExecuteStatement();
		
		Сам().ПроверитьРавенство(ТипЗначенияСтр(ТЗ), "ТаблицаЗначений");
		Сам().ПроверитьРавенство(ТЗ.КоличествоСтрок(), 1);
		
		РезИД	 = ТЗ.ПолучитьЗначение(1, "doc_id");
		РезДат	 = ТЗ.ПолучитьЗначение(1, "doc_date");
		
		Сам().ПроверитьРавенство(ТекИД, РезИД);
		Сам().ПроверитьРавенство(ТекДат, РезДат);
		
		Состояние("Обработано строк: " + П);
	КонецЦикла;
	
	cmd.Unprepare();
	cmd.Закрыть();
КонецПроцедуры // Тест_OLEDBData_Парам_Док9_Дата()

//_____________________________________________________________________________
//
Процедура Тест_OLEDBData_Парам_Число15_3Число_1() Экспорт
	Перем cmd;
	Перем тЗапрос;
	Перем ТЗэт, ТЗ;
	Перем ТекП1, ТекП2, РезП1;
	
	//Сам().ПропуститьТест(, "новый функционал, еще не реализован в репозитарии");
	
	cmd = СоздатьИСоединить();
	
	тЗапрос = "
	|SELECT 
	|	SprT.id as id, 
	|	SprT.descr as descr, 
	|	SprT.code as code, 
	|	$SprT.Число15_3 as price 
	|FROM 
	|	$Справочник.ТестовыеДанные as SprT 
	|WHERE 
	|	SprT.isfolder = 2 
	|ORDER BY 
	|	SprT.code 
	|";
	
	ТЗэт = cmd.ExecuteStatement(тЗапрос);
	
	// Должна быть ТЗ и хоть одна строка для прогона теста
	//
	Сам().ПроверитьРавенство(ТипЗначенияСтр(ТЗэт), "ТаблицаЗначений");
	Сам().ПроверитьБольшеИлиРавно(ТЗэт.КоличествоСтрок(), 1);
	
	cmd.ДобПараметр(1, 14, 16, 3, ""); // Число15_3
	cmd.ДобПараметр(1, 14, 1, 0, ""); // isfolder
	cmd.ДобПараметр(1, 129, 5, 0, ""); // code
	
	тЗапрос = "
	|SELECT TOP 1 
	|	SprT.id as id, 
	|	SprT.descr as descr, 
	|	SprT.code as code, 
	|	$SprT.Число15_3 as price 
	|FROM 
	|	$Справочник.ТестовыеДанные as SprT 
	|WHERE 
	|	($SprT.Число15_3 = ?) AND (SprT.isfolder = ?) AND (SprT.code = ?) 
	|ORDER BY 
	|	SprT.code 
	|";
	
	cmd.Подготовить(тЗапрос);
	
	Для П = 1 По ТЗэт.КоличествоСтрок() Цикл
		ТекП1 = ТЗэт.ПолучитьЗначение(П, "price");
		ТекП2 = ТЗэт.ПолучитьЗначение(П, "code"); // только для корректной выборки
		
		cmd.УстановитьПараметр(1, ТекП1);
		cmd.УстановитьПараметр(2, 2); // элементы только
		cmd.УстановитьПараметр(3, ТекП2);
		
		ТЗ = cmd.ExecuteStatement();
		
		Сам().ПроверитьРавенство(ТипЗначенияСтр(ТЗ), "ТаблицаЗначений");
		Сам().ПроверитьРавенство(ТЗ.КоличествоСтрок(), 1); // должна быть одна строка
		
		РезП1 = ТЗ.ПолучитьЗначение(1, "price");
		
		Сам().ПроверитьРавенство(ТекП1, РезП1);
		
		Состояние("Обработано строк: " + П);
	КонецЦикла;
	
	cmd.Unprepare();
	cmd.Закрыть();
КонецПроцедуры // Тест_OLEDBData_Парам_Число15_3Число_1()

//_____________________________________________________________________________
//
Процедура Тест_OLEDBData_Парам_Типы1С_КакSTR() Экспорт
	Перем cmd;
	Перем тФайл;
	Перем тЗапрос;
	Перем FromStr, FromNum, FromDate, FromEnum, FromRef, FromDoc;
	Перем _FromStr, _FromNum, _FromDate, _FromEnum, _FromRef, _FromDoc;
	Перем FromClndr9, FromClndr13, FromKind9, FromKind13;
	Перем _FromClndr9, _FromClndr13, _FromKind9, _FromKind13;
	Перем FromAcc9, FromAcc13, FromSbKd9, FromSbKd13, FromChrt9, FromChrt13;
	Перем _FromAcc9, _FromAcc13, _FromSbKd9, _FromSbKd13, _FromChrt9, _FromChrt13;
	Перем МДВ;
	Перем ТЗ;
	Перем Рез;
	
	//Сам().ПропуститьТест(, "новый функционал, еще не реализован в репозитарии");
	
	МДВ = СоздатьОбъект("MetaDataWork");
	
	cmd = СоздатьИСоединить();
	
	тФайл = КаталогИБ();
	тФайл = тФайл + ?(Прав(тФайл, 1) = "\", "", "\") + "TblTps1C.dbf";
	
	// Заботимся, чтобы файла не было перед началом теста
	//
	Если ФС.СуществуетФайл(тФайл) > 0 Тогда
		тЗапрос = "DROP TABLE [TblTps1C];";
		
		Попытка
			cmd.Execute(тЗапрос);
		Исключение
			Попытка
				ФС.УдалитьФайл(тФайл);
			Исключение
			КонецПопытки;
			
			Сам().ПроверитьРавенство(ФС.СуществуетФайл(тФайл), 0);
		КонецПопытки;
	КонецЕсли;
	
	тЗапрос = "
	|CREATE TABLE [TblTps1C] ( 
	|	FromStr c(6), 
	|	FromNum c(5), 
	|	FromDate c(8), 
	|	FromEnum c(9), 
	|	FromRef c(9), 
	|	FromDoc c(9), 
	|	FromClnd9 c(9), 
	|	FromClnd13 c(13), 
	|	FromKind9 c(9), 
	|	FromKind13 c(13), 
	|	FromAcc9 c(9), 
	|	FromAcc13 c(13), 
	|	FromSbKd9 c(9), 
	|	FromSbKd13 c(13), 
	|	FromChrt9 c(9), 
	|	FromChrt13 c(13) 
	|) 
	|";
	
	cmd.Execute(тЗапрос);
	
	FromStr	 = "строка";
	_FromStr = FromStr;
	
	FromNum	 = 12345;
	_FromNum = "12345";
	
	FromDate = Дата(2007, 02, 18);
	_FromDate = "20070218";
	
	FromEnum = Перечисление.Новый1.новый1;
	_FromEnum = МДВ.ЗначениеВСтрокуБД(FromEnum);
	
	FromRef	 = ПолучитьПустоеЗначение("Справочник.ТестовыеДанные");
	_FromRef = МДВ.ЗначениеВСтрокуБД(FromRef); // '     0   '
	
	FromDoc	 = ПолучитьПустоеЗначение("Документ.Новый1");
	_FromDoc = МДВ.ЗначениеВСтрокуБД(FromDoc); // '     0   '
	
	FromClndr9 = СоздатьОбъект("Календарь.Пятидневка");
	_FromClndr9 = МДВ.ЗначениеВСтрокуБД(FromClndr9); // "    1E   "
	
	FromClndr13 = СоздатьОбъект("Календарь.Шестидневка");
	_FromClndr13 = МДВ.ЗначениеВДлиннуюСтрокуБД(FromClndr13); // "   0    1E   "
	
	FromKind9 = ВидРасчета.ЛюбойРасчет1;
	_FromKind9 = МДВ.ЗначениеВСтрокуБД(FromKind9); // "    1E   "
	
	FromKind13 = ВидРасчета.ЛюбойРасчет2;
	_FromKind13 = МДВ.ЗначениеВДлиннуюСтрокуБД(FromKind13); // "   0    1E   "
	
	FromAcc9 = СчетПоКоду("00");
	_FromAcc9 = МДВ.ЗначениеВСтрокуБД(FromAcc9);
	
	FromAcc13 = СчетПоКоду("01");
	_FromAcc13 = МДВ.ЗначениеВДлиннуюСтрокуБД(FromAcc13);
	
	FromSbKd9 = ВидыСубконто.ЛюбойВидСубконто1;
	_FromSbKd9 = МДВ.ЗначениеВСтрокуБД(FromSbKd9);
	
	FromSbKd13 = ВидыСубконто.ЛюбойВидСубконто2;
	_FromSbKd13 = МДВ.ЗначениеВДлиннуюСтрокуБД(FromSbKd13);
	
	FromChrt9 = ПланыСчетов.ЗначениеПоИдентификатору("Основной");
	_FromChrt9 = МДВ.ЗначениеВСтрокуБД(FromChrt9);
	
	FromChrt13 = ПланыСчетов.ЗначениеПоИдентификатору("Основной");
	_FromChrt13 = МДВ.ЗначениеВДлиннуюСтрокуБД(FromChrt13);
	
	cmd.ДобПараметр(1, 129, 6, 0, ""); // FromStr
	cmd.ДобПараметр(1, 129, 5, 0, ""); // FromNum
	cmd.ДобПараметр(1, 129, 10, 0, ""); // FromDate
	cmd.ДобПараметр(1, 129, 9, 0, ""); // FromEnum
	cmd.ДобПараметр(1, 129, 9, 0, ""); // FromRef
	cmd.ДобПараметр(1, 129, 9, 0, ""); // FromDoc
	cmd.ДобПараметр(1, 129, 9, 0, ""); // FromClndr9
	cmd.ДобПараметр(1, 129, 13, 0, ""); // FromClndr13
	cmd.ДобПараметр(1, 129, 9, 0, ""); // FromKind9
	cmd.ДобПараметр(1, 129, 13, 0, ""); // FromKind13
	cmd.ДобПараметр(1, 129, 9, 0, ""); // FromAcc9
	cmd.ДобПараметр(1, 129, 13, 0, ""); // FromAcc13
	cmd.ДобПараметр(1, 129, 9, 0, ""); // FromSbKd9
	cmd.ДобПараметр(1, 129, 13, 0, ""); // FromSbKd13
	cmd.ДобПараметр(1, 129, 9, 0, ""); // FromChrt9
	cmd.ДобПараметр(1, 129, 13, 0, ""); // FromChrt13
	
	тЗапрос = "
	|INSERT INTO [TblTps1C] ( 
	|	FromStr, FromNum, FromDate, 
	|	FromEnum, FromRef, FromDoc, 
	|	FromClnd9, FromClnd13, FromKind9, 
	|	FromKind13, FromAcc9, FromAcc13, 
	|	FromSbKd9, FromSbKd13, FromChrt9, FromChrt13) 
	|	VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?) 
	|";
	
	cmd.Подготовить(тЗапрос);
	
	cmd.УстановитьПараметр(1, FromStr);
	cmd.УстановитьПараметр(2, FromNum);
	cmd.УстановитьПараметр(3, FromDate);
	cmd.УстановитьПараметр(4, FromEnum);
	cmd.УстановитьПараметр(5, FromRef);
	cmd.УстановитьПараметр(6, FromDoc);
	cmd.УстановитьПараметр(7, FromClndr9);
	cmd.УстановитьПараметр(8, FromClndr13);
	cmd.УстановитьПараметр(9, FromKind9);
	cmd.УстановитьПараметр(10, FromKind13);
	cmd.УстановитьПараметр(11, FromAcc9);
	cmd.УстановитьПараметр(12, FromAcc13);
	cmd.УстановитьПараметр(13, FromSbKd9);
	cmd.УстановитьПараметр(14, FromSbKd13);
	cmd.УстановитьПараметр(15, FromChrt9);
	cmd.УстановитьПараметр(16, FromChrt13);
	
	cmd.Execute();
	cmd.Unprepare();
	
	тЗапрос = "
	|SELECT 
	|	FromStr, 
	|	FromNum, 
	|	FromDate, 
	|	FromEnum, 
	|	FromRef, 
	|	FromDoc, 
	|	FromClnd9, 
	|	FromClnd13, 
	|	FromKind9, 
	|	FromKind13, 
	|	FromAcc9, 
	|	FromAcc13, 
	|	FromSbKd9, 
	|	FromSbKd13, 
	|	FromChrt9, 
	|	FromChrt13 
	|FROM [TblTps1C] 
	|";
	
	ТЗ = cmd.ExecuteStatement(тЗапрос);
	
	Сам().ПроверитьРавенство(ТипЗначенияСтр(ТЗ), "ТаблицаЗначений");
	Сам().ПроверитьРавенство(ТЗ.КоличествоСтрок(), 1); // должна быть одна строка
	
	Рез = ТЗ.ПолучитьЗначение(1, "FromStr");
	Сам().ПроверитьРавенство(_FromStr, Рез);
	
	Рез = ТЗ.ПолучитьЗначение(1, "FromNum");
	Сам().ПроверитьРавенство(_FromNum, Рез);
	
	Рез = ТЗ.ПолучитьЗначение(1, "FromDate");
	Сам().ПроверитьРавенство(_FromDate, Рез);
	
	Рез = ТЗ.ПолучитьЗначение(1, "FromEnum");
	Сам().ПроверитьРавенство(_FromEnum, Рез);
	
	Рез = ТЗ.ПолучитьЗначение(1, "FromRef");
	Сам().ПроверитьРавенство(_FromRef, Рез);
	
	Рез = ТЗ.ПолучитьЗначение(1, "FromDoc");
	Сам().ПроверитьРавенство(_FromDoc, Рез);
	
	Рез = ТЗ.ПолучитьЗначение(1, "FromClnd9");
	Сам().ПроверитьРавенство(_FromClndr9, Рез);
	
	Рез = ТЗ.ПолучитьЗначение(1, "FromClnd13");
	Сам().ПроверитьРавенство(_FromClndr13, Рез);
	
	Рез = ТЗ.ПолучитьЗначение(1, "FromKind9");
	Сам().ПроверитьРавенство(_FromKind9, Рез);
	
	Рез = ТЗ.ПолучитьЗначение(1, "FromKind13");
	Сам().ПроверитьРавенство(_FromKind13, Рез);
	
	Рез = ТЗ.ПолучитьЗначение(1, "FromAcc9");
	Сам().ПроверитьРавенство(_FromAcc9, Рез);
	
	Рез = ТЗ.ПолучитьЗначение(1, "FromAcc13");
	Сам().ПроверитьРавенство(_FromAcc13, Рез);
	
	Рез = ТЗ.ПолучитьЗначение(1, "FromSbKd9");
	Сам().ПроверитьРавенство(_FromSbKd9, Рез);
	
	Рез = ТЗ.ПолучитьЗначение(1, "FromSbKd13");
	Сам().ПроверитьРавенство(_FromSbKd13, Рез);
	
	Рез = ТЗ.ПолучитьЗначение(1, "FromChrt9");
	Сам().ПроверитьРавенство(_FromChrt9, Рез);
	
	Рез = ТЗ.ПолучитьЗначение(1, "FromChrt13");
	Сам().ПроверитьРавенство(_FromChrt13, Рез);
	
	cmd.Закрыть();
КонецПроцедуры // Тест_OLEDBData_Парам_Типы1С_КакSTR()

//_____________________________________________________________________________
//
Процедура Тест_OLEDBData_Парам_integer() Экспорт
	Перем тЗапрос;
	Перем тФайл;
	Перем тзПарам, ТЗ;
	Перем cmd;
	Перем ТекЗначР, ТекЗначЭ;
	
	//Сам().ПропуститьТест(, "новый функционал, еще не реализован в репозитарии");
	
	cmd = СоздатьИСоединить();
	
	тФайл = КаталогИБ();
	тФайл = тФайл + ?(Прав(тФайл, 1) = "\", "", "\") + "TblInt.dbf";
	
	// Заботимся, чтобы файла не было перед началом теста
	//
	Если ФС.СуществуетФайл(тФайл) > 0 Тогда
		тЗапрос = "DROP TABLE [TblInt];";
		
		Попытка
			cmd.Execute(тЗапрос);
		Исключение
			Попытка
				ФС.УдалитьФайл(тФайл);
			Исключение
			КонецПопытки;
			
			Сам().ПроверитьРавенство(ФС.СуществуетФайл(тФайл), 0);
		КонецПопытки;
	КонецЕсли;
	
	cmd.Execute("CREATE TABLE [TblInt] (id Integer, val Integer);");
	
	тзПарам = СоздатьОбъект("ТаблицаЗначений");
	тзПарам.НоваяКолонка("Значение", "Число");
	
	тзПарам.НоваяСтрока();
	тзПарам.Значение = 123;
	
	тзПарам.НоваяСтрока();
	тзПарам.Значение = -123;
	
	тзПарам.НоваяСтрока();
	тзПарам.Значение = 7534.45;
	
	тзПарам.НоваяСтрока();
	тзПарам.Значение = -9123.45;
	
	тзПарам.НоваяСтрока();
	тзПарам.Значение = 1213.457890;
	
	тзПарам.НоваяСтрока();
	тзПарам.Значение = -144423.457890;
	
	тзПарам.НоваяСтрока();
	тзПарам.Значение = 2147483647;
	
	тзПарам.НоваяСтрока();
	тзПарам.Значение = -2147483647;
	
	тзПарам.НоваяСтрока();
	тзПарам.Значение = 2147483648; // переполнение, в файле должно быть 0
	
	тзПарам.НоваяСтрока();
	тзПарам.Значение = -2147483648; // переполнение, в файле должно быть 0
	
	cmd.ДобПараметр(1, 3, 4, 0, ""); // id - колонка нужна только для упорядочивания
	cmd.ДобПараметр(1, 3, 4, 0, ""); // val - проверяемое значение
	
	cmd.Подготовить("INSERT INTO [TblInt] (id, val) VALUES (?, ?);");
	
	Для Н = 1 По тзПарам.КоличествоСтрок() Цикл
		cmd.УстановитьПараметр(1, Н);
		cmd.УстановитьПараметр(2, тзПарам.ПолучитьЗначение(Н, "Значение"));
		
		cmd.Execute();
	КонецЦикла;
	cmd.Unprepare();
	
	ТЗ = cmd.ExecuteStatement("SELECT val FROM [TblInt] ORDER BY id;");
	
	// Кол-во строк должно быть одинаково
	//
	Сам().ПроверитьРавенство(тзПарам.КоличествоСтрок(), ТЗ.КоличествоСтрок());
	
	Для Н = 1 По ТЗ.КоличествоСтрок() Цикл
		ТекЗначР = ТЗ.ПолучитьЗначение(Н, "val");
		ТекЗначЭ = тзПарам.ПолучитьЗначение(Н, "Значение");
		ТекЗначЭ = Окр(ТекЗначЭ, 0, 1);
		
		Если (АБС(ТекЗначЭ) > 2147483647) Тогда // переполнение, в файле должно быть 0
			Сам().ПроверитьНеравенство(ТекЗначЭ, ТекЗначР);
		Иначе
			Сам().ПроверитьРавенство(ТекЗначЭ, ТекЗначР);
		КонецЕсли;
	КонецЦикла;
КонецПроцедуры // Тест_OLEDBData_Парам_integer()

//_____________________________________________________________________________
//
Функция Пустые_MemoПоля_Начало()
	OLEDBData = OLEDBData();
	
	ИмяКаталогаВременныхФайлов = "C:\" + "КаталогВременныхФайлов\";
	СоздатьКаталог(ИмяКаталогаВременныхФайлов);
	
	СтрокаПодключения = "
	|Provider=VFPOLEDB.1;
	|Data Source=" + ИмяКаталогаВременныхФайлов;
	
	лРезультатСоединения = OLEDBData.Соединение(СтрокаПодключения);
	Сам().ПроверитьРавенство(лРезультатСоединения, 1);
	
	OLEDBCommand = OLEDBData.СоздатьКоманду();
	
	ИмяФайла = "Q326544";
	
	Сам().ДобавитьВременныйФайл(ИмяКаталогаВременныхФайлов + ИмяФайла + ".dbf");
	Сам().ДобавитьВременныйФайл(ИмяКаталогаВременныхФайлов + ИмяФайла + ".fpt");
	
	ТекстЗапроса = "
	|CREATE TABLE " + ИмяФайла + " (FIELD1 N(1,0), fldMEMO M, FIELD2 N(1,0))
	|";
	
	лКоличество = OLEDBCommand.Выполнить(ТекстЗапроса);
	Сам().ПроверитьРавенство(лКоличество, -1);
	
	ТекстЗапроса = "
	|INSERT INTO " + ИмяФайла + " VALUES (12, [], 11);
	|";
	
	лКоличество = OLEDBCommand.Выполнить(ТекстЗапроса);
	Сам().ПроверитьРавенство(лКоличество, 1);
	
	Возврат ИмяФайла;
КонецФункции // Пустые_MemoПоля_Начало()

//_____________________________________________________________________________
//
Процедура Пустые_MemoПоля_ВыполнитьИнструкцию(ТекстЗапроса, ИмяФайла)
	ТекстЗапроса1 = ТекстЗапроса + " from " + ИмяФайла;
	
	лТабЗапроса = OLEDBCommand.ВыполнитьИнструкцию(ТекстЗапроса1);
	
	Сам().ПроверитьРавенство(ТипЗначенияСтр(лТабЗапроса), "ТаблицаЗначений");
	Сам().ПроверитьРавенство(лТабЗапроса.КоличествоСтрок(), 1);
КонецПроцедуры // Пустые_MemoПоля_ВыполнитьИнструкцию()

//_____________________________________________________________________________
//
Процедура Тест_Пустые_MemoПоля1() Экспорт
	// баг, описанный в http://www.1cpp.ru/forum/YaBB.pl?num=1173772600/0
	// тест для NET - http://support.microsoft.com/kb/326544
	//
	ИмяФайла = Пустые_MemoПоля_Начало();
	
	ТекстЗапроса = "select *";
	
	Пустые_MemoПоля_ВыполнитьИнструкцию(ТекстЗапроса, ИмяФайла);
КонецПроцедуры // Тест_Пустые_MemoПоля1()

//_____________________________________________________________________________
//
Процедура Тест_Пустые_MemoПоля2() Экспорт
	// баг, описанный в http://www.1cpp.ru/forum/YaBB.pl?num=1173772600/0
	// тест для NET - http://support.microsoft.com/kb/326544
	//
	ИмяФайла = Пустые_MemoПоля_Начало();
	
	ТекстЗапроса = "select fldMEMO";
	
	Пустые_MemoПоля_ВыполнитьИнструкцию(ТекстЗапроса, ИмяФайла);
КонецПроцедуры // Тест_Пустые_MemoПоля2()

//_____________________________________________________________________________
//
Процедура Тест_Пустые_MemoПоля3() Экспорт
	// баг, описанный в http://www.1cpp.ru/forum/YaBB.pl?num=1173772600/0
	// тест для NET - http://support.microsoft.com/kb/326544
	//
	ИмяФайла = Пустые_MemoПоля_Начало();
	
	ТекстЗапроса = "
	|select fldMEMO, FIELD1, FIELD2";
	
	Пустые_MemoПоля_ВыполнитьИнструкцию(ТекстЗапроса, ИмяФайла);
КонецПроцедуры // Тест_Пустые_MemoПоля3()

//_____________________________________________________________________________
//
Процедура Тест_Пустые_MemoПоля4() Экспорт
	// баг, описанный в http://www.1cpp.ru/forum/YaBB.pl?num=1173772600/0
	// тест для NET - http://support.microsoft.com/kb/326544
	//
	ИмяФайла = Пустые_MemoПоля_Начало();
	
	ТекстЗапроса = "
	|select FIELD1, fldMEMO, FIELD2";
	
	Пустые_MemoПоля_ВыполнитьИнструкцию(ТекстЗапроса, ИмяФайла);
КонецПроцедуры // Тест_Пустые_MemoПоля4()

//_____________________________________________________________________________
//
Процедура Тест_OLEDB_QRY_Дата() Экспорт
	Перем cmd; // : OLEDBCommand
	Перем ТЗ; // : ТаблицаЗначений
	Перем Спр; // : Справочник.ТестовыеДанные
	Перем Стр; // : Число
	Перем тЗапрос; // : Строка
	
	//Сам().ПропуститьТест(, "новый функционал, еще не реализован в репозитарии");
	
	cmd = СоздатьИСоединить();
	
	тЗапрос = "
	|SELECT 
	|	SprT.id as id, 
	|	CAST(LTRIM(RTRIM(SprT.code)) as V(5)) as Код, 
	|	CAST(RTRIM(SprT.descr) as V(100)) as Наименование, 
	|	$SprT.Дата as Дата 
	|FROM 
	|	$Справочник.ТестовыеДанные as SprT 
	|WHERE 
	|	SprT.isfolder = 2 
	|ORDER BY 
	|	SprT.code 
	|";
	
	ТЗ = cmd.ExecuteStatement(тЗапрос);
	
	Сам().ПроверитьРавенство(ТипЗначенияСтр(ТЗ), "ТаблицаЗначений");
	Сам().ПроверитьБольше(ТЗ.КоличествоСтрок(), 0);
	
	Спр = СоздатьОбъект("Справочник.ТестовыеДанные");
	Спр.ПорядокКодов();
	Спр.ВыбратьЭлементы();
	Пока Спр.ПолучитьЭлемент() > 0 Цикл
		Если Спр.ЭтоГруппа() > 0 Тогда
			Продолжить;
		КонецЕсли;
		
		// Позиционируемся в ТЗ по коду
		//
		Стр = 0;
		Сам().ПроверитьРавенство(ТЗ.НайтиЗначение(Спр.Код, Стр, "Код"), 1);
		Сам().ПроверитьБольше(Стр, 0);
		
		// Сравниваем эталон с результатом запроса
		//
		Сам().ПроверитьРавенство(ТЗ.ПолучитьЗначение(Стр, "Дата"), Спр.Дата);
	КонецЦикла;
	
	cmd.Закрыть();
КонецПроцедуры // Тест_OLEDB_QRY_Дата()

//_____________________________________________________________________________
//
Процедура Тест_OLEDB_QRY_Календарь() Экспорт
	Перем cmd; // : OLEDBCommand
	Перем ТЗ; // : ТаблицаЗначений
	Перем Спр; // : Справочник.ТестовыеДанные
	Перем Стр; // : Число
	Перем тЗапрос; // : Строка
	
	//Сам().ПропуститьТест(, "новый функционал, еще не реализован в репозитарии");
	
	cmd = СоздатьИСоединить();
	
	тЗапрос = "
	|SELECT 
	|	SprT.id as id, 
	|	CAST(LTRIM(RTRIM(SprT.code)) as V(5)) as Код, 
	|	CAST(RTRIM(SprT.descr) as V(100)) as Наименование, 
	|	$SprT.Календарь1 as [Календарь1 $Календарь], 
	|	$SprT.Календарь2 as [Календарь2 $Календарь] 
	|FROM 
	|	$Справочник.ТестовыеДанные as SprT 
	|WHERE 
	|	SprT.isfolder = 2 
	|ORDER BY 
	|	SprT.code 
	|";
	
	ТЗ = cmd.ExecuteStatement(тЗапрос);
	
	Сам().ПроверитьРавенство(ТипЗначенияСтр(ТЗ), "ТаблицаЗначений");
	Сам().ПроверитьБольше(ТЗ.КоличествоСтрок(), 0);
	
	Спр = СоздатьОбъект("Справочник.ТестовыеДанные");
	Спр.ПорядокКодов();
	Спр.ВыбратьЭлементы();
	Пока Спр.ПолучитьЭлемент() > 0 Цикл
		Если Спр.ЭтоГруппа() > 0 Тогда
			Продолжить;
		КонецЕсли;
		
		// Позиционируемся в ТЗ по коду
		//
		Стр = 0;
		Сам().ПроверитьРавенство(ТЗ.НайтиЗначение(Спр.Код, Стр, "Код"), 1);
		Сам().ПроверитьБольше(Стр, 0);
		
		// Сравниваем эталон с результатом запроса
		//
		Сам().ПроверитьРавенство(ТЗ.ПолучитьЗначение(Стр, "Календарь1"), Спр.Календарь1);
		Сам().ПроверитьРавенство(ТЗ.ПолучитьЗначение(Стр, "Календарь2"), Спр.Календарь2);
	КонецЦикла;
	
	cmd.Закрыть();
КонецПроцедуры // Тест_OLEDB_QRY_Календарь()

//_____________________________________________________________________________
//
Процедура Тест_OLEDB_QRY_ВидРасчетаКакРеквизит() Экспорт
	Перем cmd; // : OLEDBCommand
	Перем ТЗ; // : ТаблицаЗначений
	Перем Спр; // : Справочник.ТестовыеДанные
	Перем Стр; // : Число
	Перем тЗапрос; // : Строка
	
	//Сам().ПропуститьТест(, "новый функционал, еще не реализован в репозитарии");
	
	cmd = СоздатьИСоединить();
	
	тЗапрос = "
	|SELECT 
	|	SprT.id as id, 
	|	CAST(LTRIM(RTRIM(SprT.code)) as V(5)) as Код, 
	|	CAST(RTRIM(SprT.descr) as V(100)) as Наименование, 
	|	$SprT.ВидРасчета as [ВидРасчета $ВидРасчета] 
	|FROM 
	|	$Справочник.ТестовыеДанные as SprT 
	|WHERE 
	|	SprT.isfolder = 2 
	|ORDER BY 
	|	SprT.code 
	|";
	
	ТЗ = cmd.ExecuteStatement(тЗапрос);
	
	Сам().ПроверитьРавенство(ТипЗначенияСтр(ТЗ), "ТаблицаЗначений");
	Сам().ПроверитьБольше(ТЗ.КоличествоСтрок(), 0);
	
	Спр = СоздатьОбъект("Справочник.ТестовыеДанные");
	Спр.ПорядокКодов();
	Спр.ВыбратьЭлементы();
	Пока Спр.ПолучитьЭлемент() > 0 Цикл
		Если Спр.ЭтоГруппа() > 0 Тогда
			Продолжить;
		КонецЕсли;
		
		// Позиционируемся в ТЗ по коду
		//
		Стр = 0;
		Сам().ПроверитьРавенство(ТЗ.НайтиЗначение(Спр.Код, Стр, "Код"), 1);
		Сам().ПроверитьБольше(Стр, 0);
		
		// Сравниваем эталон с результатом запроса
		//
		Сам().ПроверитьРавенство(ТЗ.ПолучитьЗначение(Стр, "ВидРасчета"), Спр.ВидРасчета);
	КонецЦикла;
	
	cmd.Закрыть();
КонецПроцедуры // Тест_OLEDB_QRY_ВидРасчетаКакРеквизит()

//_____________________________________________________________________________
//
Процедура Тест_OLEDB_QRY_Счет() Экспорт
	Перем cmd; // : OLEDBCommand
	Перем ТЗ; // : ТаблицаЗначений
	Перем Спр; // : Справочник.ТестовыеДанные
	Перем Стр; // : Число
	Перем тЗапрос; // : Строка
	
	//Сам().ПропуститьТест(, "новый функционал, еще не реализован в репозитарии");
	
	cmd = СоздатьИСоединить();
	
	тЗапрос = "
	|SELECT 
	|	SprT.id as id, 
	|	CAST(LTRIM(RTRIM(SprT.code)) as V(5)) as Код, 
	|	CAST(RTRIM(SprT.descr) as V(100)) as Наименование, 
	|	$SprT.Счет as [Счет $Счет], 
	|	$SprT.СчетОсновной as [СчетОсновной $Счет.Основной] 
	|FROM 
	|	$Справочник.ТестовыеДанные as SprT 
	|WHERE 
	|	SprT.isfolder = 2 
	|ORDER BY 
	|	SprT.code 
	|";
	
	ТЗ = cmd.ExecuteStatement(тЗапрос);
	
	Сам().ПроверитьРавенство(ТипЗначенияСтр(ТЗ), "ТаблицаЗначений");
	Сам().ПроверитьБольше(ТЗ.КоличествоСтрок(), 0);
	
	Спр = СоздатьОбъект("Справочник.ТестовыеДанные");
	Спр.ПорядокКодов();
	Спр.ВыбратьЭлементы();
	Пока Спр.ПолучитьЭлемент() > 0 Цикл
		Если Спр.ЭтоГруппа() > 0 Тогда
			Продолжить;
		КонецЕсли;
		
		// Позиционируемся в ТЗ по коду
		//
		Стр = 0;
		Сам().ПроверитьРавенство(ТЗ.НайтиЗначение(Спр.Код, Стр, "Код"), 1);
		Сам().ПроверитьБольше(Стр, 0);
		
		// Сравниваем эталон с результатом запроса
		//
		Сам().ПроверитьРавенство(ТЗ.ПолучитьЗначение(Стр, "Счет"), Спр.Счет);
		Сам().ПроверитьРавенство(ТЗ.ПолучитьЗначение(Стр, "СчетОсновной"), Спр.СчетОсновной);
	КонецЦикла;
	
	cmd.Закрыть();
КонецПроцедуры // Тест_OLEDB_QRY_Счет()

//_____________________________________________________________________________
//
Процедура Тест_OLEDB_QRY_ПланСчетовКакРеквизит() Экспорт
	Перем cmd; // : OLEDBCommand
	Перем ТЗ; // : ТаблицаЗначений
	Перем Спр; // : Справочник.ТестовыеДанные
	Перем Стр; // : Число
	Перем тЗапрос; // : Строка
	
	//Сам().ПропуститьТест(, "новый функционал, еще не реализован в репозитарии");
	
	cmd = СоздатьИСоединить();
	
	тЗапрос = "
	|SELECT 
	|	SprT.id as id, 
	|	CAST(LTRIM(RTRIM(SprT.code)) as V(5)) as Код, 
	|	CAST(RTRIM(SprT.descr) as V(100)) as Наименование, 
	|	$SprT.ПланСчетов as [ПланСчетов $ПланСчетов] 
	|FROM 
	|	$Справочник.ТестовыеДанные as SprT 
	|WHERE 
	|	SprT.isfolder = 2 
	|ORDER BY 
	|	SprT.code 
	|";
	
	ТЗ = cmd.ExecuteStatement(тЗапрос);
	
	Сам().ПроверитьРавенство(ТипЗначенияСтр(ТЗ), "ТаблицаЗначений");
	Сам().ПроверитьБольше(ТЗ.КоличествоСтрок(), 0);
	
	Спр = СоздатьОбъект("Справочник.ТестовыеДанные");
	Спр.ПорядокКодов();
	Спр.ВыбратьЭлементы();
	Пока Спр.ПолучитьЭлемент() > 0 Цикл
		Если Спр.ЭтоГруппа() > 0 Тогда
			Продолжить;
		КонецЕсли;
		
		// Позиционируемся в ТЗ по коду
		//
		Стр = 0;
		Сам().ПроверитьРавенство(ТЗ.НайтиЗначение(Спр.Код, Стр, "Код"), 1);
		Сам().ПроверитьБольше(Стр, 0);
		
		// Сравниваем эталон с результатом запроса
		//
		Сам().ПроверитьРавенство(ТЗ.ПолучитьЗначение(Стр, "ПланСчетов"), Спр.ПланСчетов);
	КонецЦикла;
	
	cmd.Закрыть();
КонецПроцедуры // Тест_OLEDB_QRY_ПланСчетовКакРеквизит()

//_____________________________________________________________________________
//
Процедура Тест_OLEDB_QRY_ВидСубконтоКакРеквизит() Экспорт
	Перем cmd; // : OLEDBCommand
	Перем ТЗ; // : ТаблицаЗначений
	Перем Спр; // : Справочник.ТестовыеДанные
	Перем Стр; // : Число
	Перем тЗапрос; // : Строка
	
	//Сам().ПропуститьТест(, "новый функционал, еще не реализован в репозитарии");
	
	cmd = СоздатьИСоединить();
	
	тЗапрос = "
	|SELECT 
	|	SprT.id as id, 
	|	CAST(LTRIM(RTRIM(SprT.code)) as V(5)) as Код, 
	|	CAST(RTRIM(SprT.descr) as V(100)) as Наименование, 
	|	$SprT.ВидСубконто as [ВидСубконто $ВидСубконто] 
	|FROM 
	|	$Справочник.ТестовыеДанные as SprT 
	|WHERE 
	|	SprT.isfolder = 2 
	|ORDER BY 
	|	SprT.code 
	|";
	
	ТЗ = cmd.ExecuteStatement(тЗапрос);
	
	Сам().ПроверитьРавенство(ТипЗначенияСтр(ТЗ), "ТаблицаЗначений");
	Сам().ПроверитьБольше(ТЗ.КоличествоСтрок(), 0);
	
	Спр = СоздатьОбъект("Справочник.ТестовыеДанные");
	Спр.ПорядокКодов();
	Спр.ВыбратьЭлементы();
	Пока Спр.ПолучитьЭлемент() > 0 Цикл
		Если Спр.ЭтоГруппа() > 0 Тогда
			Продолжить;
		КонецЕсли;
		
		// Позиционируемся в ТЗ по коду
		//
		Стр = 0;
		Сам().ПроверитьРавенство(ТЗ.НайтиЗначение(Спр.Код, Стр, "Код"), 1);
		Сам().ПроверитьБольше(Стр, 0);
		
		// Сравниваем эталон с результатом запроса
		//
		Сам().ПроверитьРавенство(ТЗ.ПолучитьЗначение(Стр, "ВидСубконто"), Спр.ВидСубконто);
	КонецЦикла;
	
	cmd.Закрыть();
КонецПроцедуры // Тест_OLEDB_QRY_ВидСубконтоКакРеквизит()

//_____________________________________________________________________________
//
Процедура Тест_OLEDB_QRY_ДругиеПростыеТипы() Экспорт
	Перем cmd; // : OLEDBCommand
	Перем ТЗ; // : ТаблицаЗначений
	Перем Спр; // : Справочник.ТестовыеДанные
	Перем Стр; // : Число
	Перем тЗапрос; // : Строка
	
	//Сам().ПропуститьТест(, "новый функционал, еще не реализован в репозитарии");
	
	cmd = СоздатьИСоединить();
	
	тЗапрос = "
	|SELECT 
	|	SprT.id as id, 
	|	CAST(LTRIM(RTRIM(SprT.code)) as V(5)) as Код, 
	|	CAST(RTRIM(SprT.descr) as V(100)) as Наименование, 
	|	$SprT.Строка10 as [Строка10 $Строка], 
	|	$SprT.Число10 as [Число10 $Число], 
	|	$SprT.Число15_3 as [Число15_3 $Число] 
	|FROM 
	|	$Справочник.ТестовыеДанные as SprT 
	|WHERE 
	|	SprT.isfolder = 2 
	|ORDER BY 
	|	SprT.code 
	|";
	
	ТЗ = cmd.ExecuteStatement(тЗапрос);
	
	Сам().ПроверитьРавенство(ТипЗначенияСтр(ТЗ), "ТаблицаЗначений");
	Сам().ПроверитьБольше(ТЗ.КоличествоСтрок(), 0);
	
	Спр = СоздатьОбъект("Справочник.ТестовыеДанные");
	Спр.ПорядокКодов();
	Спр.ВыбратьЭлементы();
	Пока Спр.ПолучитьЭлемент() > 0 Цикл
		Если Спр.ЭтоГруппа() > 0 Тогда
			Продолжить;
		КонецЕсли;
		
		// Позиционируемся в ТЗ по коду
		//
		Стр = 0;
		Сам().ПроверитьРавенство(ТЗ.НайтиЗначение(Спр.Код, Стр, "Код"), 1);
		Сам().ПроверитьБольше(Стр, 0);
		
		// Сравниваем эталон с результатом запроса
		//
		Сам().ПроверитьРавенство(ТЗ.ПолучитьЗначение(Стр, "Строка10"), Спр.Строка10);
		Сам().ПроверитьРавенство(ТЗ.ПолучитьЗначение(Стр, "Число10"), Спр.Число10);
		Сам().ПроверитьРавенство(ТЗ.ПолучитьЗначение(Стр, "Число15_3"), Спр.Число15_3);
	КонецЦикла;
	
	cmd.Закрыть();
КонецПроцедуры // Тест_OLEDB_QRY_ДругиеПростыеТипы()

//_____________________________________________________________________________
//
Процедура Тест_OLEDB_QRY_Субконто() Экспорт
	Перем cmd; // : OLEDBCommand
	Перем ТЗ, ТЗэт; // : ТаблицаЗначений
	Перем Стр, КолВоЭт; // : Число
	Перем тЗапрос; // : Строка
	Перем Оп; // : Операция
	
	тЗапрос = "
	|SELECT 
	|	Ent.docid as [Операция $Документ], 
	|	Jrn.iddocdef as Операция_kind, 
	|	Ent.date, Ent.time, 
	|	CAST(Ent.number + 1 as N(5,2)) as НомерПроводки, 
	|	CAST(LTRIM(RTRIM(AccDt.schkod)) as V(10)) as ДтСчет, 
	|	CAST(LTRIM(RTRIM(AccKt.schkod)) as V(10)) as КтСчет, 
	|	AccDt.schkod as ДтСчет, 
	|	AccKt.schkod as КтСчет, 
	|	Ent.sum as Сумма, 
	|	Ent.amount as Количество, 
	|	Ent.dtflags, Ent.ktflags, 
	|	Ent.vdtsc0 as ДтСбкнт1_kind, Ent.dtsc0 as [ДтСбкнт1 $Субконто], 
	|	Ent.vdtsc1 as ДтСбкнт2_kind, Ent.dtsc1 as [ДтСбкнт2 $Субконто], 
	|	Ent.vktsc0 as КтСбкнт1_kind, Ent.ktsc0 as [КтСбкнт1 $Субконто], 
	|	Ent.vktsc1 as КтСбкнт2_kind, Ent.ktsc1 as [КтСбкнт2 $Субконто] 
	|FROM 
	|	[1sentry] as Ent 
	|INNER JOIN [1sjourn] as Jrn ON Jrn.iddoc = Ent.docid 
	|LEFT JOIN [1saccs] as AccDt ON AccDt.id = Ent.accdtid 
	|LEFT JOIN [1saccs] as AccKt ON AccKt.id = Ent.accktid 
	|WHERE 
	|	(AccDt.schkod = ' 00.   ') 
	|	AND (AccKt.schkod = ' 01.   ') 
	|	AND (Ent.date >= :ДатаНач~~) AND (Ent.date <= :ДатаКон~~) 
	|	AND (Ent.active != '*') 
	|ORDER BY 
	|	Ent.date, Ent.time, Ent.docid, Ent.number 
	|";
	
	cmd = СоздатьИСоединить();
	
	cmd.УстановитьТекстовыйПараметр("ДатаНач", Дата(2007, 03, 29));
	cmd.УстановитьТекстовыйПараметр("ДатаКон", Дата(2007, 03, 29));
	
	ТЗ = cmd.ExecuteStatement(тЗапрос);
	
	Сам().ПроверитьРавенство(ТипЗначенияСтр(ТЗ), "ТаблицаЗначений");
	Сам().ПроверитьБольше(ТЗ.КоличествоСтрок(), 0);
	
	ТЗэт = СоздатьОбъект("ТаблицаЗначений");
	ТЗэт.НоваяКолонка("Операция");
	ТЗэт.НоваяКолонка("НомерПроводки", "Число");
	ТЗэт.НоваяКолонка("ДтСчет", "Строка");
	ТЗэт.НоваяКолонка("КтСчет", "Строка");
	ТЗэт.НоваяКолонка("ДтСбкнт1");
	ТЗэт.НоваяКолонка("ДтСбкнт2");
	ТЗэт.НоваяКолонка("КтСбкнт1");
	ТЗэт.НоваяКолонка("КтСбкнт2");
	
	Оп = СоздатьОбъект("Операция");
	Если Оп.ВыбратьОперацииСПроводками(Дата(2007, 03, 29), Дата(2007, 03, 29), СчетПоКоду("00"), СчетПоКоду("01"), 1) > 0 Тогда
		Пока Оп.ПолучитьПроводку() > 0 Цикл
			Дт = Оп.Дебет;
			Кт = Оп.Кредит;
			
			ТЗэт.НоваяСтрока();
			ТЗэт.Операция	 = Оп.Документ.ТекущийДокумент();
			ТЗэт.НомерПроводки = Оп.НомерПроводки();
			ТЗэт.ДтСчет		 = Дт.Счет.ТекущийСчет().Код + "."; // для совместимости с данными запроса
			ТЗэт.ДтСбкнт1	 = Дт.Субконто(1);
			ТЗэт.ДтСбкнт2	 = Дт.Субконто(2);
			ТЗэт.КтСчет		 = Кт.Счет.ТекущийСчет().Код + "."; // для совместимости с данными запроса
			ТЗэт.КтСбкнт1	 = Кт.Субконто(1);
			ТЗэт.КтСбкнт2	 = Кт.Субконто(2);
		КонецЦикла;
	КонецЕсли;
	Кт = "";
	Дт = "";
	Оп = "";
	
	// Должна быть хоть одна строка
	//
	КолВоЭт = ТЗэт.КоличествоСтрок();
	Сам().ПроверитьБольше(КолВоЭт, 0);
	
	Для Н = 1 По КолВоЭт Цикл
		Рез = ТЗ.ПолучитьЗначение(Н, "Операция");
		Сам().ПроверитьРавенство(ТЗэт.ПолучитьЗначение(Н, "Операция"), Рез);
		
		Рез = ТЗ.ПолучитьЗначение(Н, "НомерПроводки");
		Сам().ПроверитьРавенство(ТЗэт.ПолучитьЗначение(Н, "НомерПроводки"), Рез);
		
		Рез = ТЗ.ПолучитьЗначение(Н, "ДтСчет");
		Сам().ПроверитьРавенство(ТЗэт.ПолучитьЗначение(Н, "ДтСчет"), Рез);
		
		Рез = ТЗ.ПолучитьЗначение(Н, "КтСчет");
		Сам().ПроверитьРавенство(ТЗэт.ПолучитьЗначение(Н, "КтСчет"), Рез);
		
		Рез = ТЗ.ПолучитьЗначение(Н, "ДтСбкнт1");
		Сам().ПроверитьРавенство(ТЗэт.ПолучитьЗначение(Н, "ДтСбкнт1"), Рез);
		
		Рез = ТЗ.ПолучитьЗначение(Н, "ДтСбкнт2");
		Сам().ПроверитьРавенство(ТЗэт.ПолучитьЗначение(Н, "ДтСбкнт2"), Рез);
		
		Рез = ТЗ.ПолучитьЗначение(Н, "КтСбкнт1");
		Сам().ПроверитьРавенство(ТЗэт.ПолучитьЗначение(Н, "КтСбкнт1"), Рез);
		
		Рез = ТЗ.ПолучитьЗначение(Н, "КтСбкнт2");
		Сам().ПроверитьРавенство(ТЗэт.ПолучитьЗначение(Н, "КтСбкнт2"), Рез);
	КонецЦикла;
	
	cmd.Закрыть();
КонецПроцедуры // Тест_OLEDB_QRY_Субконто()

//_____________________________________________________________________________
//
Процедура Тест_OLEDB_QRY_ВыполнитьИнструкцию_Парам_ТЗ() Экспорт
	Перем cmd; // : OLEDBCommand
	Перем ТЗ; // : ТаблицаЗначений
	Перем Стр, КолВоЭт; // : Число
	Перем тЗапрос; // : Строка
	Перем КолонокЭт, Колонок; // : Число
	Перем Строк; // : Число
	
	ТЗ = СоздатьОбъект("ТаблицаЗначений");
	ТЗ.НоваяКолонка("Код", "Строка");
	ТЗ.НоваяКолонка("Наименование", "Строка");
	ТЗ.НоваяКолонка("Строчка", "Строка");
	ТЗ.НоваяКолонка("Число10", "Число");
	ТЗ.НоваяКолонка("ПустаяДолжнаБыть", "Число");
	КолонокЭт = ТЗ.КоличествоКолонок();
	
	тЗапрос = "
	|SELECT 
	|	Spr.descr as Наименование, 
	|	$Spr.Строка10 as Строка10, 
	|	$Spr.Число10 as Число10 
	|FROM 
	|	$Справочник.ТестовыеДанные as Spr 
	|ORDER BY 
	|	Spr.descr 
	|";
	
	cmd = СоздатьИСоединить();
	
	// Передаем ТЗ параметром
	// 1. после выполнения кол-во колонок в ТЗ не должно измениться
	//
	ТЗ.НоваяСтрока();
	ТЗ = cmd.ExecuteStatement(тЗапрос, ТЗ, 0); // без очистки
	//Сам().ПроверитьБольше(ТЗ.КоличествоСтрок(), 1); // должно быть более одной строки
	Сам().ПроверитьРавенство(КолонокЭт, ТЗ.КоличествоКолонок());
	
	// 2. после выполнения кол-во колонок в ТЗ должно совпадать с кол-вом полей в запросе
	//
	ТЗ = cmd.ExecuteStatement(тЗапрос, ТЗ, 1); // с очисткой
	Сам().ПроверитьБольше(ТЗ.КоличествоСтрок(), 0);
	Сам().ПроверитьРавенство(3, ТЗ.КоличествоКолонок());
	
	cmd.Закрыть();
КонецПроцедуры // Тест_OLEDB_QRY_ВыполнитьИнструкцию_Парам_ТЗ

//_____________________________________________________________________________
//
Процедура Тест_OLEDB_QRY_ВыполнитьИнструкцию_ДокНеопр() Экспорт
	Перем cmd; // : OLEDBCommand
	Перем ТЗ; // : ТаблицаЗначений
	Перем тЗапрос; // : Строка
	Перем Спр; // : Справочник.ТестовыеДанные
	
	тЗапрос = "
	|SELECT 
	|	CAST(LTRIM(RTRIM(Spr.code)) as V(5)) as Код, 
	|	Spr.id as [Объект $Справочник.ТестовыеДанные], 
	|	$Spr.ДокументНеопр as [Док $Документ] 
	|FROM 
	|	$Справочник.ТестовыеДанные as Spr 
	|WHERE 
	|	Spr.isfolder = 2 
	|ORDER BY 
	|	Spr.code 
	|";
	
	cmd = СоздатьИСоединить();
	
	ТЗ = cmd.ExecuteStatement(тЗапрос);
	
	Сам().ПроверитьРавенство(ТипЗначенияСтр(ТЗ), "ТаблицаЗначений");
	Сам().ПроверитьБольше(ТЗ.КоличествоСтрок(), 0);
	
	Спр = СоздатьОбъект("Справочник.ТестовыеДанные");
	Спр.ПорядокКодов();
	Спр.ВыбратьЭлементы();
	Пока Спр.ПолучитьЭлемент() > 0 Цикл
		Если Спр.ЭтоГруппа() > 0 Тогда
			Продолжить;
		КонецЕсли;
		
		// Позиционируемся в ТЗ по коду
		//
		Стр = 0;
		Сам().ПроверитьРавенство(ТЗ.НайтиЗначение(Спр.Код, Стр, "Код"), 1);
		Сам().ПроверитьБольше(Стр, 0);
		
		// Сравниваем эталон с результатом запроса
		//
		Сам().ПроверитьРавенство(ТЗ.ПолучитьЗначение(Стр, "Док"), Спр.ДокументНеопр);
	КонецЦикла;
КонецПроцедуры // Тест_OLEDB_QRY_ВыполнитьИнструкцию_ДокНеопр()