// тесты проверки работы 1С++ в плане ООП

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

Функция База() Возврат Конт(Контекст).ПолучитьБазовыйКласс(); КонецФункции

Процедура ТестСозданиеКласса() Экспорт
  Перем Объект;

  Сам = Сам();

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

Процедура ТестТипЗначенияСтрПриСозданииВДругомРегистре() Экспорт
  Перем Объект;

  Сам = Сам();

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

Процедура ТестЧтениеАтрибута() Экспорт
  Перем Объект;

  Сам = Сам();

  Объект = СоздатьОбъект("ООППредок");

  Сам.ПроверитьРавенство(Объект.АтрибутБазовогоКласса, 1);
КонецПроцедуры //ТестЧтениеАтрибута

Процедура ТестЧтениеАтрибутаВДругомРегистре() Экспорт
  Перем Объект;

  Сам = Сам();

  Объект = СоздатьОбъект("ООППредок");

  Сам.ПроверитьРавенство(Объект.атрибутБазовогоклассА, 1);
КонецПроцедуры //ТестЧтениеАтрибутаВДругомРегистре

Процедура ТестЗаписьАтрибута() Экспорт
  Перем Объект;

  Сам = Сам();

  Объект = СоздатьОбъект("ООППредок");
  Объект.АтрибутБазовогоКласса = -1;

  Сам.ПроверитьРавенство(Объект.АтрибутБазовогоКласса, -1);
КонецПроцедуры //ТестЗаписьАтрибута

Процедура ТестЗаписьАтрибутаВДругомРегистре() Экспорт
  Перем Объект;

  Сам = Сам();

  Объект = СоздатьОбъект("ООППредок");
  Объект.АтрибутБазовогоКласса = -1;

  Сам.ПроверитьРавенство(Объект.атрибутБазовогоклассА, -1);
КонецПроцедуры //ТестЗаписьАтрибутаВДругомРегистре

Процедура ТестВызовФункции() Экспорт
  Перем Объект;

  Сам = Сам();

  Объект = СоздатьОбъект("ООППредок");

  Сам.ПроверитьРавенство(Объект.ОткрытаяФункция(), 1);
  Сам.ПроверитьРавенство(Объект.ПолучитьПоследнийВызванныйМетод(), "ОткрытаяФункция");
КонецПроцедуры //ТестВызовФункции

Процедура ТестВызовФункцииВДругомРегистре() Экспорт
  Перем Объект;

  Сам = Сам();

  Объект = СоздатьОбъект("ООППредок");

  Сам.ПроверитьРавенство(Объект.открытаяФункциЯ(), 1);
  Сам.ПроверитьРавенство(Объект.ПолучитьПоследнийВызванныйМетод(), "ОткрытаяФункция");
КонецПроцедуры //ТестВызовФункцииВДругомРегистре

Процедура ТестВызовПроцедуры() Экспорт
  Перем Объект;

  Сам = Сам();

  Объект = СоздатьОбъект("ООППредок");
  Объект.ОткрытаяПроцедура();

  Сам.ПроверитьРавенство(Объект.ПолучитьПоследнийВызванныйМетод(), "ОткрытаяПроцедура");
КонецПроцедуры //ТестВызовПроцедуры

Процедура ТестВызовПроцедурыВДругомРегистре() Экспорт
  Перем Объект;

  Сам = Сам();

  Объект = СоздатьОбъект("ООППредок");
  Объект.открытаяПроцедурА();

  Сам.ПроверитьРавенство(Объект.ПолучитьПоследнийВызванныйМетод(), "ОткрытаяПроцедура");
КонецПроцедуры //ТестВызовПроцедурыВДругомРегистре

Процедура ТестСозданиеПотомка() Экспорт
  Перем Объект;

  Сам = Сам();

  Объект = СоздатьОбъект("ООППотомок");
  ТипОбъекта = ТипЗначенияСтр(Объект);

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

Процедура ТестПолучитьБазовыйКлассБезИмени() Экспорт
  Перем Объект;

  Сам = Сам();

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

  Сам.ПроверитьРавенство(ТипОбъекта, "ООППредок");
КонецПроцедуры

Процедура ТестПолучитьБазовыйКлассПоИмени() Экспорт
  Перем Объект;

  Сам = Сам();

  Объект = СоздатьОбъект("ООППотомок");

  ТипБазовогоКласса = "ООППредок";
  ТипОбъекта = ТипЗначенияСтр(Объект.ПолучитьБазовыйКласс(ТипБазовогоКласса));
  Сам.ПроверитьРавенство(ТипБазовогоКласса, "ООППредок");

  Сам.ПроверитьРавенство(ТипОбъекта, "ООППредок");
КонецПроцедуры

Процедура ТестПолучитьБазовыйКлассПоИмениВДругомРегистре() Экспорт
  Перем Объект;

  Сам = Сам();

  Объект = СоздатьОбъект("ООППотомок");

  ТипБазовогоКласса = "оопПредоК";
  ТипОбъекта = ТипЗначенияСтр(Объект.ПолучитьБазовыйКласс(ТипБазовогоКласса));
  Сам.ПроверитьРавенство(ТипБазовогоКласса, "оопПредоК");

  Сам.ПроверитьРавенство(ТипОбъекта, "ООППредок");
КонецПроцедуры

Процедура ТестПолучитьБазовыйКласс_ЭтотжеКласс() Экспорт
  Сам = Сам();
  Объект = СоздатьОбъект("ООППотомок");

  База = Объект.ПолучитьБазовыйКласс("ООППотомок"); // сами себя
  Сам.ПроверитьРавенство(ТипЗначенияСтр(База), "ООППотомок");

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

Процедура ТестПолучитьБазовыйКласс_НеверныйКласс() Экспорт
  Сам = Сам();
  Объект = СоздатьОбъект("ООППотомок");

  Сам.ПроверитьРавенство(Объект.ПолучитьБазовыйКласс("СправочникПотомок"), 0); // абсолютно "левый" класс

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

Процедура ТестПолучитьБазовыйКласс_МножественноеНаследование() Экспорт
  Сам = Сам();
  Объект = СоздатьОбъект("ТестовыйСлучайФормы");

  Сам.ПроверитьРавенство(ТипЗначенияСтр(Объект.ПолучитьБазовыйКласс()), "ТестовыйСлучайСДанными");
  Сам.ПроверитьРавенство(ТипЗначенияСтр(Объект.ПолучитьБазовыйКласс("")), "ТестовыйСлучайСДанными");

  Сам.ПроверитьРавенство(ТипЗначенияСтр(Объект.ПолучитьБазовыйКласс("ДелегатФормы")), "ДелегатФормы");
  Сам.ПроверитьРавенство(ТипЗначенияСтр(Объект.ПолучитьБазовыйКласс("ТестовыйСлучайСДанными")), "ТестовыйСлучайСДанными");
  Сам.ПроверитьРавенство(ТипЗначенияСтр(Объект.ПолучитьБазовыйКласс("ТестовыйСлучай")), "ТестовыйСлучай");

  //Сам.ПроверитьРавенство(ТипЗначенияСтр(База()), "ТестовыйСлучайСДанными");
  Сам.ПроверитьРавенство(ТипЗначенияСтр(База()), "ТестовыйСлучайФормы");

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


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

Процедура Тест_ПриНаследованииОтУниверсальногоМетаданного_ПолучитьБазовыйКласс_НеверныйКласс() Экспорт
 
  Сам = Сам();
  Объект = СоздатьОбъект("СправочникПотомок");

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

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

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

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

Процедура ТестДеструкторПотомкаРаньшеЧемДеструкторПредка() Экспорт
  Перем Объект;

  Объект = СоздатьОбъект("ООППотомок");
  Объект1 = Объект.ПолучитьБазовыйКласс("");
  Объект = Объект1;
КонецПроцедуры

Процедура ТестУдалениеПотомкаРаньшеПредка() Экспорт
  Объект = СоздатьОбъект("ООППотомок");
  Объект = Объект.ПолучитьБазовыйКласс("");
КонецПроцедуры	// ТестУдалениеПотомкаРаньшеПредка

Процедура ТестУдалениеПотомкаРаньшеПредка2() Экспорт
  Объект = СоздатьОбъект("ООППотомок");
  Объект1 = Объект.ПолучитьБазовыйКласс("");
КонецПроцедуры	// 

Процедура ТестУдалениеПотомкаРаньшеПредкаИЧтениеАтрибутаБазовогоКласса() Экспорт
  Сам = Сам();

  Объект = СоздатьОбъект("ООППотомок");
  
  Объект.АтрибутБазовогоКласса = 10;
  Объект1 = Объект.ПолучитьБазовыйКласс("");
  
  Сам.ПроверитьРавенство(Объект.АтрибутБазовогоКласса, 10); 
  Сам.ПроверитьРавенство(Объект1.АтрибутБазовогоКласса, 10); 

  Объект = "";

  Сам.ПроверитьРавенство(Объект1.АтрибутБазовогоКласса, 10); 

КонецПроцедуры	// ТестУдалениеПотомкаРаньшеПредка

Процедура ТестЗаписьАтрибутаБазовогоКласса() Экспорт
  Сам = Сам();
  Объект = СоздатьОбъект("ООППотомок");
  
  Объект.АтрибутБазовогоКласса = 10;

  Объект1 = Объект.ПолучитьБазовыйКласс("");
  
  Сам.ПроверитьРавенство(Объект.АтрибутБазовогоКласса, 10); 
  Сам.ПроверитьРавенство(Объект1.АтрибутБазовогоКласса, 10); 

  Объект1.АтрибутБазовогоКласса = 11;

  Сам.ПроверитьРавенство(Объект.АтрибутБазовогоКласса, 11); 
  Сам.ПроверитьРавенство(Объект1.АтрибутБазовогоКласса, 11); 

КонецПроцедуры	// ТестУдалениеПотомкаРаньшеПредка

Процедура ТестЧтениеВПотомкеАтрибутаБазовогоКласса1() Экспорт
  Перем Объект;

  Сам = Сам();
  Объект = СоздатьОбъект("ООППотомок");
  Объект1 = Объект.ПолучитьБазовыйКласс("");
  АтрибутБазовогоКласса = Объект1.АтрибутБазовогоКласса;

  Сам.ПроверитьРавенство(АтрибутБазовогоКласса, 2); 
КонецПроцедуры //ТестЧтениеВПотомкеАтрибутаБазовогоКласса

Процедура ТестЧтениеВПотомкеАтрибутаБазовогоКласса2() Экспорт
  Перем Объект;

  Сам = Сам();

  Объект = СоздатьОбъект("ООППотомок");
  АтрибутБазовогоКласса = Объект.АтрибутБазовогоКласса;

  Сам.ПроверитьРавенство(АтрибутБазовогоКласса, 2);
КонецПроцедуры //ТестЧтениеВПотомкеАтрибутаБазовогоКласса

Процедура ТестАтрибутСОднимНазваниемУКлассовВИерархии() Экспорт
  Перем Объект;

  Сам = Сам();

  Объект = СоздатьОбъект("ООППотомок");
  АтрибутКласса = Объект.АтрибутКласса;

  Сам.ПроверитьРавенство(АтрибутКласса, 2);

  Объект = Объект.ПолучитьБазовыйКласс("");
  АтрибутКласса = Объект.АтрибутКласса;

  Сам.ПроверитьРавенство(АтрибутКласса, 1);
КонецПроцедуры //ТестАтрибутСОднимНазваниемУКлассовВИерархии

// рекомендованный синоним ЗаменитьЭксзБазовогоКласса
Процедура ТестЗаменитьБазовыйОбъект() Экспорт
  Сам = Сам();
  Объект = СоздатьОбъект("ООППотомок");

  Сам.ПроверитьРавенство(Объект.АтрибутБазовогоКласса, 2);

  Объект2 = СоздатьОбъект("ООППредок");
  Объект2.АтрибутБазовогоКласса = 3;
  
  //Объект.ЗаменитьБазовыйОбъект("ООППредок", Объект2);
  Сам.ПроверитьРавенство(Объект.ЗаменитьБазовыйОбъект("ООППредок", Объект2), 1);
  Сам.ПроверитьРавенство(Объект.АтрибутБазовогоКласса, 3);

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

КонецПроцедуры
              
Процедура Проверить_ЗаменитьБазовыйОбъектНаОшибку(Объект, НаименованиеБазовогоКласса, НаименованиеНеверногоКласса)
  Сам = Сам();

  Объект1 = СоздатьОбъект(НаименованиеНеверногоКласса);
  фРез = Объект.ЗаменитьБазовыйОбъект(НаименованиеБазовогоКласса, Объект1);
                                                 
  // возможна и такая ошибка - вернули 0, а замена все-таки произошла
  База = Объект.ПолучитьБазовыйКласс(НаименованиеНеверногоКласса);
  Сам.ПроверитьНеРавенство(ТипЗначенияСтр(База), НаименованиеНеверногоКласса);

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

// тест устаревших синонимов
Процедура ТестЗаменитьЭксзБазовогоКласса() Экспорт
  Сам = Сам();
  Объект = СоздатьОбъект("ООППотомок");

  Сам.ПроверитьРавенство(Объект.АтрибутБазовогоКласса, 2);

  Объект2 = СоздатьОбъект("ООППредок");
  Объект2.АтрибутБазовогоКласса = 3;

  Объект.ЗаменитьЭксзБазовогоКласса("ООППредок", Объект2);
  Сам.ПроверитьРавенство(Объект.АтрибутБазовогоКласса, 3);

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

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

Процедура ТестНазначитьБазовыйКласс() Экспорт
  Сам = Сам();
  Объект = СоздатьОбъект("ООППотомок");

  НовыйТип = "ООППредокВОдномФайле";
  Сам.ПроверитьИсключениеДляЛюбогоМетода(Объект, "НазначитьБазовыйКласс", НовыйТип); // Объект.НазначитьБазовыйКласс(НовыйТип);

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

Процедура Тест_ПриНаследованииОтУниверсальногоМетаданного_ЗаменитьБазовыйОбъект() Экспорт
  Сам = Сам();
  Объект = СоздатьОбъект("СправочникПотомок");

  НовыйОбъект = СоздатьОбъект("Справочник.Новый2");
  фРез = Объект.ЗаменитьБазовыйОбъект("Справочник", НовыйОбъект);
  Сам.ПроверитьРавенство(фРез, 1);

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

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

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

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

Процедура Тест_ПриНаследованииОтУниверсальногоМетаданного_ЗаменитьБазовыйОбъект_ОдинСправочникНаДругой1() Экспорт
  Сам = Сам();
  Объект = СоздатьОбъект("СправочникПотомок");

  НовыйОбъект = СоздатьОбъект("Справочник.Новый2");
  фРез = Объект.ЗаменитьБазовыйОбъект("Справочник", НовыйОбъект);

  Проверить_ЗаменитьБазовыйОбъектНаОшибку(Объект, "Справочник.Новый2", "Справочник.Новый1");

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

Процедура Тест_ПриНаследованииОтУниверсальногоМетаданного_ЗаменитьБазовыйОбъект_ОдинСправочникНаДругой2() Экспорт
  Сам = Сам();
  Объект = СоздатьОбъект("СправочникПотомок");

  НовыйОбъект = СоздатьОбъект("Справочник.Новый2");
  фРез = Объект.ЗаменитьБазовыйОбъект("Справочник", НовыйОбъект);
  Сам.ПроверитьРавенство(фРез, 1);

  Проверить_ЗаменитьБазовыйОбъектНаОшибку(Объект, "Справочник", "Справочник.Новый1");

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

Процедура Тест_ПриНаследованииОтУниверсальногоМетаданного_ЗаменитьБазовыйОбъект3() Экспорт
  Сам = Сам();
  Объект = СоздатьОбъект("СправочникПотомок");

  НовыйОбъект = СоздатьОбъект("Справочник.Новый2");
  фРез = Объект.ЗаменитьБазовыйОбъект("Справочник.Новый2", НовыйОбъект);
  Сам.ПроверитьРавенство(фРез, 0);
КонецПроцедуры

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

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

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

  Проверить_ЗаменитьБазовыйОбъектНаОшибку(Объект, "Справочник", "ООППредок");
КонецПроцедуры

Процедура Тест_ПриНаследованииОтУниверсальногоМетаданного_ЗаменитьБазовыйОбъект_ПриЗаменеОдногоМетаданногоНаДругое() Экспорт
  Сам = Сам();
  Объект = СоздатьОбъект("СправочникПотомок");

  НовыйОбъект = СоздатьОбъект("Справочник.Новый2");
  фРез = Объект.ЗаменитьБазовыйОбъект("Справочник", НовыйОбъект);

  Проверить_ЗаменитьБазовыйОбъектНаОшибку(Объект, "Справочник.Новый2", "Документ.Новый1");

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

Процедура ТестПолучитьПуть1() Экспорт
  Сам = Сам();
  Объект = СоздатьОбъект("ООППредок");

  Сам.ПроверитьРавенство(Объект.ПолучитьПуть(), КаталогИБ()+"UnitTests\OOP\Предок.txt");
КонецПроцедуры  // ТестПолучитьПуть1

Процедура ТестПолучитьПуть2() Экспорт
  Сам = Сам();
  Объект = СоздатьОбъект("ооппРЕДОК");

  Сам.ПроверитьРавенство(Объект.ПолучитьПуть(), КаталогИБ()+"UnitTests\OOP\Предок.txt");
КонецПроцедуры  // ТестПолучитьПуть1

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

  Сам.ПроверитьРавенство(Объект.ПолучитьПуть(), КаталогИБ()+"UnitTests\OOP\Потомок.txt");

  Сам.ПроверитьРавенство(Объект.ПолучитьБазовыйКласс("").ПолучитьПуть(), КаталогИБ()+"UnitTests\OOP\Предок.txt");

  Сам.ПроверитьРавенство(Объект.ПолучитьБазовыйКласс("ООППредок").ПолучитьПуть(), КаталогИБ()+"UnitTests\OOP\Предок.txt");
КонецПроцедуры  // ТестПолучитьПутьПриНаследовании

Процедура ТестПолучитьКонтекстОкружения() Экспорт
  Сам = Сам();

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

КонецПроцедуры  // ТестПолучитьКонтекстОкружения

Процедура ТестПолучитьКонтекстОкружения_1() Экспорт
  Сам = Сам();

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

КонецПроцедуры  // ТестПолучитьКонтекстОкружения

Процедура ТестПолучитьКонтекстОкружения_ИсключениеНаКопии() Экспорт
  Сам = Сам();

  Объект = СоздатьОбъект("ООППотомок");
  Объект = Объект.СоздатьКопию();

  //Сам.ПроверитьИсключениеДляЛюбогоМетода(Объект,"ПолучитьКонтекстОкружения"); // конт = Объект.ПолучитьКонтекстОкружения();

  // далее что-то непонятное, но главное, что в обычном коде 1С (без тестирования) вызовет обычное исключение

  конт = Объект.ПолучитьКонтекстОкружения(); // здесь и должно быть исключение, что-то непонятное !!

КонецПроцедуры  // ТестПолучитьКонтекстОкружения

Процедура ТестПолучитьКонтекстОкруженияДоВерхнейФормы() Экспорт
  Сам = Сам();

  Конт = СоздатьОбъект("ООППотомок");

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

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

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

  Конт = Конт.ПолучитьКонтекстОкружения();
  Сам.ПроверитьРавенство(ТипЗначенияСтр(Конт.ПолучитьКонтекстОкружения()), "ГрупповойКонтекст");

КонецПроцедуры  // ТестПолучитьКонтекстОкруженияДоВерхнейФормы

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

  фБылоИсключение = 0;
  Попытка
    Сам._ВыброситьИскл("Строка");
  Исключение
    фБылоИсключение = 1;
  КонецПопытки;

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

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

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

	Попытка
		объект = 0;
	Исключение
	КонецПопытки;
КонецПроцедуры
                          
//Процедура ТестКлассСИсключениемВДеструктореВызовЧерезПроцедуру() Экспорт
//	ТестКлассСИсключениемВДеструкторе();
//КонецПроцедуры

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

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

	Попытка
		объект = 0;
	Исключение
	КонецПопытки;

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

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

	Попытка
		объект1 = 0;
	Исключение
	КонецПопытки;

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

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

Функция ОбработкаСобытияОтКласса(отКого, стрСобытие, Данные)

  // все параметры можно менять
  отКого = "Возврат_Отправитель";
  стрСобытие = "Возврат_Информация";
  Данные = СоздатьОбъект("СписокЗначений");

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

// из этой процедуры список точно возвращается
  Возврат Список;
  //Возврат "Список";
КонецФункции

//
// тест ТестОтправитьСообщениеМодулюХоз_БезОбработчикаСобытия()
// находится в тестах для нескольких классов в одном файле
//

Процедура ТестОтправитьСообщениеМодулюХоз() Экспорт
  Перем Список;

  Сам = Сам();
  Объект = СоздатьОбъект("ООППотомок");

  отКого = "Отправитель";
  стрСобытие = "Информация";
  Данные = СоздатьОбъект("ТаблицаЗначений");

  Список = Объект.ОтправитьСообщениеМодулюХоз(отКого, стрСобытие, Данные);

// а вот здесь "Список" уже без типа :(

  Сам.ПроверитьРавенство(отКого, "Возврат_Отправитель");
  Сам.ПроверитьРавенство(стрСобытие, "Возврат_Информация");
  Сам.ПроверитьРавенство(ТипЗначенияСтр(Данные), "СписокЗначений");

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

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

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

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

  Объект = СоздатьОбъект("ООППотомок");

  фБылоИсключение = 0;
  Попытка
    Объект.ПолучитьСписокПараметров("");
  Исключение
    фБылоИсключение = 1;
  КонецПопытки;

  Сам.ПроверитьРавенство(фБылоИсключение, 1);

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

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

  Объект = СоздатьОбъект("ООППотомок");
  фБылоИсключение = 0;
  Попытка
    Объект.ПолучитьСписокПараметров("Функция");
  Исключение
    фБылоИсключение = 1;
  КонецПопытки;

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

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

  ЗакрытаяПеременная = 1;
  ОткрытаяПеременная = 2;

  Объект = СоздатьОбъект("ООППредок");
  Объект.ПрисоединитьТекущийМодуль();

// TODO функция работает, а что делает, непонятно :(
// пробовал применять как метод из ВыполняемыйМодуль, все равно не работает

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

Процедура ТестЯвляетсяОбъектом() Экспорт
  Сам().ПроверитьРавенство(Сам().ЯвляетсяОбъектом(""),0);

  Сам().ПроверитьРавенство(Сам().ЯвляетсяОбъектом("ООПТесты"),1);
  Сам().ПроверитьРавенство(Сам().ЯвляетсяОбъектом("ооптЕСТЫ"),1);
  Сам().ПроверитьРавенство(Сам().ЯвляетсяОбъектом("ТестовыйСлучайСДанными"),1);
  Сам().ПроверитьРавенство(Сам().ЯвляетсяОбъектом("ТестовыйСлучай"),1);
  Сам().ПроверитьРавенство(Сам().ЯвляетсяОбъектом("тЕСТОВЫЙсЛУЧАЙ"),1);

  Сам().ПроверитьРавенство(Сам().ЯвляетсяОбъектом("ВыполняемыйМодуль"),1);

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


Процедура ТестЯвляетсяОбъектом2() Экспорт
  Объект = СоздатьОбъект("ТестовыйСлучайФормы"); // множественное наследование

  Сам().ПроверитьРавенство(Объект.ЯвляетсяОбъектом("ТестовыйСлучай"),1);
  
  Сам().ПроверитьРавенство(Объект.ЯвляетсяОбъектом("ТестовыйСлучайСДанными"),1);

  Сам().ПроверитьРавенство(Объект.ЯвляетсяОбъектом("ДелегатФормы"),1);

  Сам().ПроверитьРавенство(Объект.ЯвляетсяОбъектом("ВыполняемыйМодуль"),1);

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

//  проверка бага 2038 http://cvs.alterplast.ru/bugs/show_bug.cgi?id=2038
Процедура ТестЗаменитьБазовыйОбъектКонтекстомОткрытогоДокумента() Экспорт
	КонтекстДокумента = 0;
	ОткрытьФорму("Документ.Новый2", КонтекстДокумента);

	_Сам = СоздатьОбъект("Документ_Новый2");
    _Сам.ЗаменитьБазовыйОбъект("Документ.Новый2", КонтекстДокумента);
	_Сам.ОченьНужныйМетод();

	КонтекстДокумента.Форма.Закрыть(0);
КонецПроцедуры

//  проверка бага 2038 http://cvs.alterplast.ru/bugs/show_bug.cgi?id=2038
Процедура ТестЗаменитьБазовыйОбъектКонтекстомОткрытогоДокумента_3() Экспорт
	КонтекстДокумента = 0;
	ОткрытьФорму("Документ.Новый2", КонтекстДокумента);

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

	КонтекстДокумента._Сам.ЗаменитьБазовыйОбъект("Документ.Новый2", КонтекстДокумента);

	КонтекстДокумента._Сам.ОченьНужныйМетод();

	//баг уже решен !! // если закомментировать следующую строку, 1С падает !!
	КонтекстДокумента._Сам = 0;

	КонтекстДокумента.Форма.Закрыть(0);
КонецПроцедуры

//  проверка бага 2038 http://cvs.alterplast.ru/bugs/show_bug.cgi?id=2038
Процедура ТестЗаменитьБазовыйОбъектКонтекстомОткрытогоДокумента_2() Экспорт
	КонтекстДокумента = 0;
	ОткрытьФорму("Документ.Новый2", КонтекстДокумента);

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

	КонтекстДокумента._Сам.ЗаменитьБазовыйОбъект("Документ.Новый2", КонтекстДокумента);

	КонтекстДокумента._Сам.ОченьНужныйМетод();

	//баг уже решен !! // если убрать следующий коммент, 1С не падает
	////КонтекстДокумента._Сам = 0;

	КонтекстДокумента.Форма.Закрыть(0);
КонецПроцедуры

//  проверка бага 1689 http://cvs.alterplast.ru/bugs/show_bug.cgi?id=1689
Процедура Тест_Документ_Записать() Экспорт
	Док1 = СоздатьОбъект("Документ.Новый1");
	фНашлиДокумент = 0;
	Док1.ВыбратьДокументы(,);
	Пока Док1.ПолучитьДокумент()=1  Цикл
		фНашлиДокумент = 1;
		Прервать;
	КонецЦикла;
	Если фНашлиДокумент = 0 Тогда
		рез = 0/1;
	КонецЕсли;

	НовыйНомер = 15987;
	Док = СоздатьОбъект("Документ_Записать");
	Док.НайтиДокумент(Док1.ТекущийДокумент());
	Док.НомерДок = НовыйНомер;
	Док.Записать(); // вот здесь тест как будто должен вылетать

	Док1 = СоздатьОбъект("Документ.Новый1");
	фНашлиДокумент = 0;
	Док1.ВыбратьДокументы(,);
	Пока Док1.ПолучитьДокумент()=1  Цикл
		фНашлиДокумент = 1;
		Прервать;
	КонецЦикла;
	Если фНашлиДокумент = 0 Тогда
		рез = 0/1;
	КонецЕсли;
	Сам().ПроверитьРавенство(Строка(НовыйНомер), Строка(Док1.НомерДок));
КонецПроцедуры

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

	База = Объект.ПолучитьБазовыйКласс();
	Сам().ПроверитьРавенство(ТипЗначенияСтр(База), "ГрупповойКонтекст");
	Сам().ПроверитьРавенство(ТипЗначения(База), 100);

	База = Объект.ПолучитьБазовыйКласс("ГрупповойКонтекст");
	Сам().ПроверитьРавенство(ТипЗначенияСтр(База), "ГрупповойКонтекст");

	Сам().ПроверитьРавенство(ТипЗначения(База), 100);

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

Процедура ТестНаследникГрупповойКонтекстДляОткрытойФормы() Экспорт
	Объект = СоздатьОбъект("НаследникГрупповойКонтекст");

	КонтекстДокумента = 0;
	ОткрытьФорму("Документ.Новый2", КонтекстДокумента);

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

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

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

	КонтекстДокумента.Форма.Закрыть(0);
КонецПроцедуры

// проверка бага http://itland.ru/forum/index.php?showtopic=15237&st=40
Процедура ТестНаследникГрупповойКонтекстДляОткрытойФормы_ПроверкаИсключенийВМодулеФормы() Экспорт

	Объект = СоздатьОбъект("НаследникГрупповойКонтекст");

	Сам().ПроверитьИсключениеДляЛюбогоМетода(Объект, "МетодФормыСИключением"); //Объект.МетодФормыСИключением();

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

// проверка бага 1821 http://cvs.alterplast.ru/bugs/show_bug.cgi?id=1821
Процедура Тест_ПолучитьКод() Экспорт

  Сам = Сам();

  Объект = СоздатьОбъект("ООППредок");
  Сам.ПроверитьРавенство(Строка(Объект), "ОбъектООПредок");
КонецПроцедуры	//

Процедура Тест_ПолучитьКод_Потомок() Экспорт

  Сам = Сам();

  Объект = СоздатьОбъект("ООППотомок");
  Сам.ПроверитьРавенство(Строка(Объект), "ОбъектООПредок");
КонецПроцедуры	//

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

  Сам = Сам();

  Объект = СоздатьОбъект("ООППредокВОдномФайле");
  Сам.ПроверитьРавенство(Строка(Объект), "ОбъектООППредокВОдномФайле");
КонецПроцедуры	//

Процедура Тест_ПолучитьКод_БезНаследованияПотомок() Экспорт

  Сам = Сам();

  Объект = СоздатьОбъект("ООППотомокВОдномФайле");
  Сам.ПроверитьРавенство(Строка(Объект), "ООППотомокВОдномФайле");
КонецПроцедуры	//

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

  Сам = Сам();

  Объект = СоздатьОбъект("ООППотомок");
  Сам.ПроверитьРавенство(Объект.АтрибутБазовогоКлассаМеняемыйТолькоВПредке, 1);
КонецПроцедуры	// Тест_ВызовКонструктораБазовогоКласса

Процедура Тест_ПолучитьТипЗначенияСтрВМетодеПотомка() Экспорт

  Сам = Сам();

	// метод ПолучитьТипЗначенияСтр() определен только в предке

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

Процедура Тест_ЦиклическаяИерархия() Экспорт
	Сам().ПроверитьИсключениеДляЛюбогоМетода(ПолучитьПустоеЗначение("Строка"), "СоздатьОбъект", "Класс_ЦиклическаяИерархия"); // Объект = СоздатьОбъект("Класс_ЦиклическаяИерархия");
КонецПроцедуры	//

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

Процедура Тест_ЦиклическаяИерархияЧерезПотомка2() Экспорт
	Сам().ПроверитьИсключениеДляЛюбогоМетода(ПолучитьПустоеЗначение("Строка"), "СоздатьОбъект", "Класс_ЦиклическаяИерархия_Предок"); // Объект = СоздатьОбъект("Класс_ЦиклическаяИерархия_Предок");
КонецПроцедуры	//

Процедура Тест_ЦиклическаяИерархияЧерезПотомка3() Экспорт
	Сам().ПроверитьИсключениеДляЛюбогоМетода(ПолучитьПустоеЗначение("Строка"), "СоздатьОбъект", "Класс_ЦиклическаяИерархия_Потомок"); // Объект = СоздатьОбъект("Класс_ЦиклическаяИерархия_Потомок");
КонецПроцедуры	//

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

Процедура ТестПроверкаУдаленияОбъекта() Экспорт
  Перем Объект;

  Объект = СоздатьОбъект("ООППредок");
  Объект = 0;
КонецПроцедуры

Процедура ТестПроверкаУдаленияОбъектаПроизводногоКласса() Экспорт
  Перем Объект;

  Объект = СоздатьОбъект("ООППотомок");
  Объект = 0;
КонецПроцедуры

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

  фРез = Объект.ЗаменитьБазовыйОбъект("Справочник", КонтФормыСправочника);
  Сам().ПроверитьРавенство(1, фРез);

  КонтФормыСправочника.Форма.Закрыть(0);
КонецПроцедуры

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

  КонтФормыСправочника = 0;
  ОткрытьФорму("Справочник.Новый2.ФормаСписка", КонтФормыСправочника);

  фРез = Объект.ЗаменитьБазовыйОбъект("Справочник", КонтФормыСправочника);
  Сам().ПроверитьРавенство(0, фРез);

  КонтФормыСправочника.Форма.Закрыть(0);
КонецПроцедуры

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

  КонтФормыДокумента = 0;
  ОткрытьФорму("Документ.Новый1", КонтФормыДокумента);

  фРез = Объект.ЗаменитьБазовыйОбъект("Справочник", КонтФормыДокумента);
  Сам().ПроверитьРавенство(0, фРез);

  фРез = Объект.ЗаменитьБазовыйОбъект("ГрупповойКонтекст", КонтФормыДокумента);
  Сам().ПроверитьРавенство(0, фРез);

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

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

	ПроверитьБазовыйДокумент(Объект);
КонецПроцедуры	// Тест_ПолучитьБазовыйКласс_ДляДокумента_ЧерезПромежуточныйКласс

Процедура ЗаменитьБазовыйДокументЧерезВиртуальнуюФунциюБазовогоКласса(Объект)
  Сам = Сам();

  Док = СоздатьОбъект("Документ.Новый1");
  
  фРез = Объект.НазначитьКонтекст(Док);
  Сам.ПроверитьРавенство(1, фРез);  
  
	ПроверитьБазовыйДокумент(Объект);
КонецПроцедуры	// ЗаменитьБазовыйДокумент

Процедура Тест_ЗаменитьБазовыйОбъект_ДляДокумента_ЧерезПромежуточныйКлассСВиртуальнойФункцией() Экспорт
  
  Объект = СоздатьОбъект("ДокументПотомокКонкретныйДокумент");

  ЗаменитьБазовыйДокументЧерезВиртуальнуюФунциюБазовогоКласса(Объект);
КонецПроцедуры	// Тест_ПолучитьБазовыйКласс_ДляДокумента_ЧерезПромежуточныйКласс

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

  ЗаменитьБазовыйДокументЧерезВиртуальнуюФунциюБазовогоКласса(Объект);
КонецПроцедуры	// Тест_ПолучитьБазовыйКласс_ДляДокумента_ЧерезПромежуточныйКласс

Процедура Тест_ЗаменитьБазовыйОбъект_ДляДокумента_ЧерезПромежуточныйКлассСВиртуальнойФункцией2() Экспорт
  
  Объект = СоздатьОбъект("ДокументПотомокКонкретныйДокумент2");

  ЗаменитьБазовыйДокументЧерезВиртуальнуюФунциюБазовогоКласса(Объект);
КонецПроцедуры	// Тест_ПолучитьБазовыйКласс_ДляДокумента_ЧерезПромежуточныйКласс

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

  фРез = Объект.ЗаменитьБазовыйОбъект("Документ", КонтФормыДокумента);
  Сам().ПроверитьРавенство(1, фРез);

  ПроверитьБазовыйДокумент(Объект, "ГрупповойКонтекст");

  КонтФормыДокумента.Форма.Закрыть(0);
КонецПроцедуры

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

  фРез = Объект.НазначитьКонтекст(КонтФормыДокумента);
  Сам().ПроверитьРавенство(1, фРез);

  ПроверитьБазовыйДокумент(Объект, "ГрупповойКонтекст");

  КонтФормыДокумента.Форма.Закрыть(0);
КонецПроцедуры

///******************************** ADirks 27.10.2006
//Этот тест вызывает падение 1С
Процедура Тест_ВызовВиртуальногоМетода() Экспорт
  Сам = Сам();
  
  Объект = СоздатьОбъект("ДокументПотомокКонкретныйДокумент2");
                                                    
  КонтФормыДокумента = 0;
  ОткрытьФорму("Документ.Новый1.ФормаСписка", КонтФормыДокумента);

  Объект.НазначитьКонтекст(КонтФормыДокумента);
  
  фРез = Объект.ВиртуальныйМетод(); //Здесь падение!
  Сам().ПроверитьРавенство(1, фРез);

  КонтФормыДокумента.Форма.Закрыть(0);
КонецПроцедуры
///******************************** ADirks 27.10.2006

///******************************** ADirks 27.10.2006
Процедура Тест_ВызовВиртуальногоМетода2() Экспорт
  Сам = Сам();

  Объект = СоздатьОбъект("ДокументПотомокКонкретныйДокумент2");
                                                    
  фРез = Объект.ВиртуальныйМетод(); //Здесь падение!
  Сам().ПроверитьРавенство(1, фРез);
КонецПроцедуры
///******************************** ADirks 27.10.2006

Процедура ТестПолучитьБазовыйКласссРегистры() Экспорт
	Сам = Сам();

	Объект = СоздатьОбъект("РегистрыПотомок");
                                         
	Информатор = СоздатьОбъект("Информатор");

	ТипОбъекта = Информатор.ТипЗначенияСтрВнутр(Объект.ПолучитьБазовыйКласс(""));
  	Сам.ПроверитьРавенство(ТипОбъекта, "CAllRegsContext");
	
	ТипОбъекта = Информатор.ТипЗначенияСтрВнутр(Объект.ПолучитьБазовыйКласс("Регистры"));
	Сам.ПроверитьРавенство(ТипОбъекта, "CAllRegsContext");

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

Процедура Тест_ПередаемМетодуБольшеПараметров() Экспорт
	Сам = Сам();

	Объект = СоздатьОбъект("ООППотомок");
	Сам.ПроверитьИсключениеДляЛюбогоМетода(Объект, "МетодCКоличествомПараметров1", 1, 2);
		
КонецПроцедуры

Процедура Тест_ПередаемМетодуМеньшеПараметров() Экспорт
	Сам = Сам();

	Объект = СоздатьОбъект("ООППотомок");
	Сам.ПроверитьИсключениеДляЛюбогоМетода(Объект, "МетодCКоличествомПараметров1");
		
КонецПроцедуры


Процедура Тест_ЗаменитьБазовыйОбъектНаКонтекстМодуляПроведенияВМодуле() Экспорт
	Перем КонтекстФормы;

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

	Сам.ПроверитьРавенство(Док.Проведен(), 1);
	
	Сам.ПроверитьРавенство(ТипЗначенияСтр(ПараметрСписок), "СписокЗначений");
	
	Объект = ПараметрСписок.Получить("Объект");
	фЗаменитьБазовыйОбъект = ПараметрСписок.Получить("фЗаменитьБазовыйОбъект");

	Сам.ПроверитьРавенство(фЗаменитьБазовыйОбъект, 1);
	Сам.ПроверитьРавенство(ТипЗначенияСтр(Объект), "Документ_Новый2");
	Сам.ПроверитьРавенство(ТипЗначенияСтр(Объект.ПолучитьБазовыйКласс()), "ГрупповойКонтекст");

	Сам.ПроверитьРавенство(ТипЗначенияСтр(Объект.ДатаДок), "Дата");
	Сам.ПроверитьРавенство(Объект.ДатаДок, ТекущаяДата());
	Сам.ПроверитьРавенство(ТипЗначенияСтр(Объект.Выбран()), "Число");
	Сам.ПроверитьРавенство(Объект.Выбран(), 1);
	Сам.ПроверитьРавенство(Объект.Проведен(), 1);

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

Процедура Тест_ЗаменитьБазовыйОбъектНаКонтекстФормыДокументаНаФорме() Экспорт
	Перем КонтекстФормы;

	Сам=Сам();

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

	Сам.ПроверитьРавенство(фЗаменитьБазовыйОбъект, 1);
	Сам.ПроверитьРавенство(ТипЗначенияСтр(Объект), "Документ_Новый2");
	Сам.ПроверитьРавенство(ТипЗначенияСтр(Объект.ПолучитьБазовыйКласс()), "ГрупповойКонтекст");

	ПараметрСписок = СоздатьОбъект("СписокЗначений");;
	лВыбран = КонтекстФормы.Сам_Выбран(ПараметрСписок);
	Сам.ПроверитьРавенство(ТипЗначенияСтр(лВыбран), "Число");
	Сам.ПроверитьРавенство(лВыбран, 1);
	
	Объект = ПараметрСписок.Получить("Объект");
	фЗаменитьБазовыйОбъект = ПараметрСписок.Получить("фЗаменитьБазовыйОбъект");

	Сам.ПроверитьРавенство(фЗаменитьБазовыйОбъект, 1);
	Сам.ПроверитьРавенство(ТипЗначенияСтр(Объект), "Документ_Новый2");
	Сам.ПроверитьРавенство(ТипЗначенияСтр(Объект.ПолучитьБазовыйКласс()), "ГрупповойКонтекст");

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

Процедура Тест_ЗаменитьБазовыйОбъектНаКонтекстФормыДокумента() Экспорт
	Сам=Сам();
	
	Док = СоздатьОбъект("Документ.Новый2");
	Док.Новый();
	Док.Записать();
	КонтекстФормы=Сам.ОткрытьФорму(Док.ТекущийДокумент());
	
	Док = СоздатьОбъект("Документ_Новый2");
	фЗаменитьБазовыйОбъект = Док.ЗаменитьБазовыйОбъект("Документ.Новый2", КонтекстФормы);
	Сам.ПроверитьРавенство(фЗаменитьБазовыйОбъект, 1);
	Сам.ПроверитьРавенство(ТипЗначенияСтр(Док), "Документ_Новый2");
	Сам.ПроверитьРавенство(ТипЗначенияСтр(Док.ПолучитьБазовыйКласс()), "ГрупповойКонтекст");
	
	Сам.ПроверитьРавенство(ТипЗначенияСтр(Док.ДатаДок), "Дата");
	Сам.ПроверитьРавенство(Док.ДатаДок, ТекущаяДата());
	Сам.ПроверитьРавенство(ТипЗначенияСтр(Док.Выбран()), "Число");
	Сам.ПроверитьРавенство(Док.Выбран(), 1);
КонецПроцедуры 