tests/binary-objects.os - develop - EvilBeaver/OneScript

tests/binary-objects.os
561 строка35 KB
EvilBeaver
Исправление ошибки
18 дек 2025, 23:15
18 дек 2025, 23:15af962b1

Перем юТест;

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

Функция ПолучитьСписокТестов(ЮнитТестирование) Экспорт
	
	юТест = ЮнитТестирование;
	
	ВсеТесты = Новый Массив;
	
	ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоСоздаетсяБуферДвоичныхДанных");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьРазделениеБуфераДвоичныхДанныхНесколькимиБуферами");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоМожноЗаписатьБайты");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоМожноПрочитатьБайты");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоМожноЗаписатьПрочитатьЦелое16");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоМожноЗаписатьПрочитатьЦелое16BigEndian");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоМожноЗаписатьПрочитатьЦелое32");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоМожноЗаписатьПрочитатьЦелое32BigEndian");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоМожноЗаписатьПрочитатьЦелое64");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоМожноЗаписатьПрочитатьЦелое64BigEndian");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоСоздаетсяФайловыйПоток");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоСоздаетсяПотокВПамяти");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоВозможнаЗаписьВФайл");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоСчитываетсяТекстДвоичнымЧтением");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоЧтениеДанныхЧитаетВсеДанныеМетодомПрочитатьСимволы");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоЗаписьДанныхНеЗакрываетПоток");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоПриЗаписиВБуферСНевернымИндексомВыбрасываетсяИсключение");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоКорректноРаботаютПобитовыеОперацииЗаписиВБуферДвоичныхДанных");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоМетодОткрытьПотокДляЧтенияВозвращаетПотокТолькоДляЧтения");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоПолучитьПотокТолькоДляЧтенияЗапрещаетЗапись");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоПолучитьПотокТолькоДляЧтенияРазделяетДанныеИПозицию");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоХешированиеРаботаетСПотоком");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоХешированиеРаботаетСДвоичнымиДанными");
	ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоПрочитатьБайтНеВыбрасываетИсключениеВКонцеПотока");
	
	ВсеТесты.Добавить("ТестДолжен_ПроверитьРазделениеБуфераДвоичныхДанныхОднимБуфером");

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

Процедура ПослеЗапускаТеста() Экспорт
	
	юТест.УдалитьВременныеФайлы();
	
КонецПроцедуры

Функция ПолучитьБуферСДанными()

	Буфер = Новый БуферДвоичныхДанных(10);
	Для Сч = 0 По 9 Цикл
		Буфер[Сч] = Сч+1;
	КонецЦикла;

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

Процедура ТестДолжен_ПроверитьЧтоСоздаетсяБуферДвоичныхДанных() Экспорт
	
	Б = ПолучитьБуферСДанными();
	юТест.ПроверитьРавенство(10, Б.Размер);
	Для Сч = 0 По Б.Размер-1 Цикл
		юТест.ПроверитьРавенство(Сч+1, Б[Сч], "Проверка значения в индексе " + Сч);
	КонецЦикла;
	
КонецПроцедуры

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

Процедура ТестДолжен_ПроверитьЧтоМожноПрочитатьБайты() Экспорт
	
	Б = ПолучитьБуферСДанными();
	Прочитанный = Б.Прочитать(2,2);
	
	юТест.ПроверитьРавенство(2, Прочитанный.Размер);
	юТест.ПроверитьРавенство(3, Прочитанный[0]);
	юТест.ПроверитьРавенство(4, Прочитанный[1]);
	
КонецПроцедуры

Процедура ТестДолжен_ПроверитьЧтоМожноЗаписатьПрочитатьЦелое16() Экспорт
	
	Б = Новый БуферДвоичныхДанных(4);
	Б.ЗаписатьЦелое16(0, 255);
	юТест.ПроверитьРавенство(255, Б.ПрочитатьЦелое16(0));
	
КонецПроцедуры

Процедура ТестДолжен_ПроверитьЧтоМожноЗаписатьПрочитатьЦелое16BigEndian() Экспорт
	
	Б = Новый БуферДвоичныхДанных(4);
	Б.ЗаписатьЦелое16(0, 255);
	юТест.ПроверитьРавенство(65280, Б.ПрочитатьЦелое16(0, ПорядокБайтов.BigEndian));
	
КонецПроцедуры

Процедура ТестДолжен_ПроверитьЧтоМожноЗаписатьПрочитатьЦелое32() Экспорт
	
	юТест.ПодробныеОписанияОшибок(Истина);
	
	Б = Новый БуферДвоичныхДанных(4);
	Б.ЗаписатьЦелое32(0, 4278190080);
	юТест.ПроверитьРавенство(4278190080, Б.ПрочитатьЦелое32(0));
	
КонецПроцедуры

Процедура ТестДолжен_ПроверитьЧтоМожноЗаписатьПрочитатьЦелое32BigEndian() Экспорт
	
	Б = Новый БуферДвоичныхДанных(4);
	Б.ЗаписатьЦелое32(0, 255);
	юТест.ПроверитьРавенство(4278190080, Б.ПрочитатьЦелое32(0, ПорядокБайтов.BigEndian));
	
КонецПроцедуры

Процедура ТестДолжен_ПроверитьЧтоМожноЗаписатьПрочитатьЦелое64() Экспорт
	
	Б = Новый БуферДвоичныхДанных(8);
	Б.ЗаписатьЦелое32(0, 255);
	юТест.ПроверитьРавенство(255, Б.ПрочитатьЦелое32(0));
	
КонецПроцедуры

Процедура ТестДолжен_ПроверитьЧтоМожноЗаписатьПрочитатьЦелое64BigEndian() Экспорт
	
	Б = Новый БуферДвоичныхДанных(8);
	Б.ЗаписатьЦелое64(0, 255);
	юТест.ПроверитьРавенство(18374686479671623680, Б.ПрочитатьЦелое64(0, ПорядокБайтов.BigEndian));
	
КонецПроцедуры

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

	ПотокСЕмкостью = Новый ПотокВПамяти(100);
	ПростоПоток = Новый ПотокВПамяти;
	Буфер = Новый БуферДвоичныхДанных(10);
	ПотокПоБуферу = Новый ПотокВПамяти(Буфер);
	юТест.ПроверитьРавенство(10, ПотокПоБуферу.Размер());

	ПотокПоБуферу.КопироватьВ(ПотокСЕмкостью);
	юТест.ПроверитьРавенство(10, ПотокСЕмкостью.Размер());
	
КонецПроцедуры

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

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

Процедура ТестДолжен_ПроверитьЧтоСчитываетсяТекстДвоичнымЧтением() Экспорт
	ДД = Новый ДвоичныеДанные(ОбъединитьПути(ТекущийСценарий().Каталог, "templateslib/TemplateData.txt"));
	ЧтениеДанных = Новый ЧтениеДанных(ДД);
	Строка = ЧтениеДанных.ПрочитатьСтроку();
	
	юТест.ПроверитьРавенство("ПРИВЕТ, Я МАКЕТ", Строка);
КонецПроцедуры

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

	ДД = Новый ДвоичныеДанные(ОбъединитьПути(ТекущийСценарий().Каталог, "templateslib/TemplateData.txt"));
	ЧтениеДанных = Новый ЧтениеДанных(ДД);
	ЧтениеДанных.Пропустить(3);
	Строка = ЧтениеДанных.ПрочитатьСимволы();

	юТест.ПроверитьРавенство("ПРИВЕТ, Я МАКЕТ", Строка, "Неопределено");
	ЧтениеДанных.Закрыть();

	ЧтениеДанных = Новый ЧтениеДанных(ДД);
	ЧтениеДанных.Пропустить(3);
	Строка = ЧтениеДанных.ПрочитатьСимволы(0);
	юТест.ПроверитьРавенство("ПРИВЕТ, Я МАКЕТ", Строка, "Ноль символов");
	ЧтениеДанных.Закрыть();

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

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

	Текст = "Какой-то текст";
	Кодировка = "UTF-8";

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

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

Процедура ТестДолжен_ПроверитьЧтоПриЗаписиВБуферСНевернымИндексомВыбрасываетсяИсключение() Экспорт

	ВторойБуфер = ПолучитьБуферДвоичныхДанныхИзHexСтроки("01 02 03 04");

	Попытка
		Буфер = ПолучитьБуферДвоичныхДанныхИзHexСтроки("01 02 03");
		Буфер.ЗаписатьПобитовоеИсключительноеИли(3, ВторойБуфер);
	Исключение
		юТест.ПроверитьВхождение(ОписаниеОшибки(), "Переполнение при работе с буфером");
	КонецПопытки;

	Попытка
		Буфер = ПолучитьБуферДвоичныхДанныхИзHexСтроки("01 02 03");
		Буфер.ЗаписатьПобитовоеИсключительноеИли(0, ВторойБуфер);
	Исключение
		юТест.ПроверитьВхождение(ОписаниеОшибки(), "Переполнение при работе с буфером");
	КонецПопытки;

	Попытка
		Буфер = ПолучитьБуферДвоичныхДанныхИзHexСтроки("01 02 03");
		Буфер.ЗаписатьПобитовоеИсключительноеИли(1, ВторойБуфер, 3);
	Исключение
		юТест.ПроверитьВхождение(ОписаниеОшибки(), "Переполнение при работе с буфером");
	КонецПопытки;

	Попытка
		Буфер = ПолучитьБуферДвоичныхДанныхИзHexСтроки("01 02 03");
		Буфер.ЗаписатьПобитовоеИсключительноеИли(-1, ВторойБуфер, 3);
	Исключение
		юТест.ПроверитьВхождение(ОписаниеОшибки(), "Значение индекса выходит за пределы диапазона");
	КонецПопытки;

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

Процедура ТестДолжен_ПроверитьЧтоКорректноРаботаютПобитовыеОперацииЗаписиВБуферДвоичныхДанных() Экспорт

	ВторойБуфер = ПолучитьБуферДвоичныхДанныхИзHexСтроки("01 02 03 04");
	
	Буфер = ПолучитьБуферДвоичныхДанныхИзHexСтроки("01 02 03");
	Буфер.ЗаписатьПобитовоеИсключительноеИли(0, ПолучитьБуферДвоичныхДанныхИзHexСтроки("01 02 03"));
	юТест.ПроверитьРавенство(ПолучитьHexСтрокуИзБуфераДвоичныхДанных(Буфер), "000000");

	Буфер = ПолучитьБуферДвоичныхДанныхИзHexСтроки("01 02 03");
	Буфер.ЗаписатьПобитовоеИсключительноеИли(0, ВторойБуфер, 3);
	юТест.ПроверитьРавенство(ПолучитьHexСтрокуИзБуфераДвоичныхДанных(Буфер), "000000");

	Буфер = ПолучитьБуферДвоичныхДанныхИзHexСтроки("01 02 03");
	Буфер.ЗаписатьПобитовоеИ(1, ВторойБуфер, 2);
	юТест.ПроверитьРавенство(ПолучитьHexСтрокуИзБуфераДвоичныхДанных(Буфер), "010002");
	
	Буфер = ПолучитьБуферДвоичныхДанныхИзHexСтроки("01 02 03");
	Буфер.ЗаписатьПобитовоеИли(1, ВторойБуфер, 2);
	юТест.ПроверитьРавенство(ПолучитьHexСтрокуИзБуфераДвоичныхДанных(Буфер), "010303");
	
	Буфер = ПолучитьБуферДвоичныхДанныхИзHexСтроки("01 02 03");
	Буфер.ЗаписатьПобитовоеИНе(1, ВторойБуфер, 2);
	юТест.ПроверитьРавенство(ПолучитьHexСтрокуИзБуфераДвоичныхДанных(Буфер), "010201");
	
	Буфер = ПолучитьБуферДвоичныхДанныхИзHexСтроки("01 02 03");
	Буфер.ЗаписатьПобитовоеИсключительноеИли(1, ВторойБуфер, 2);
	юТест.ПроверитьРавенство(ПолучитьHexСтрокуИзБуфераДвоичныхДанных(Буфер), "010301");

	Буфер = ПолучитьБуферДвоичныхДанныхИзHexСтроки("00 00 00");
	Буфер.ЗаписатьПобитовоеИли(1, ВторойБуфер, 2);
	юТест.ПроверитьРавенство(ПолучитьHexСтрокуИзБуфераДвоичныхДанных(Буфер), "000102");

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

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

	Поток = ПолучитьДвоичныеДанныеИзHexСтроки("1b1ec4166a11c03b3afefaea442e7709").ОткрытьПотокДляЧтения();
	юТест.ПроверитьЛожь(Поток.ДоступнаЗапись);
	юТест.ПроверитьИстину(Поток.ДоступноИзменениеПозиции);
	юТест.ПроверитьИстину(Поток.ДоступноЧтение);

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

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

	Поток = Новый ПотокВПамяти();
	Буфер = Новый БуферДвоичныхДанных(10);
	Поток.Записать(Буфер, 0, 10); // Запишем какие-то данные

	// Получим поток только для чтения
	ПотокДляЧтения = Поток.ПолучитьПотокТолькоДляЧтения();

	// Проверим, что поток помечен как read-only
	юТест.ПроверитьЛожь(ПотокДляЧтения.ДоступнаЗапись);

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

	// Также проверим, что изменение размера тоже запрещено
	Попытка
		ПотокДляЧтения.УстановитьРазмер(20);
		ВызватьИсключение "Ожидали исключение при изменении размера потока только для чтения, но его не было";
	Исключение
		ОписаниеОшибки = ИнформацияОбОшибке().Описание;
		юТест.ПроверитьВхождение(ОписаниеОшибки, "Попытка записи в поток не поддерживающий запись");
	КонецПопытки;

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

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

	// Создаем поток с данными
	Поток = Новый ПотокВПамяти();
	Буфер = Новый БуферДвоичныхДанных(20);
	
	// Заполним буфер данными
	Для Индекс = 0 По 19 Цикл
		Буфер.Установить(Индекс, Индекс + 1);
	КонецЦикла;
	
	Поток.Записать(Буфер, 0, 20);
	юТест.ПроверитьРавенство(20, Поток.Размер());
	юТест.ПроверитьРавенство(20, Поток.ТекущаяПозиция());
	
	// Сбросим позицию на начало
	Поток.Перейти(0, ПозицияВПотоке.Начало);
	юТест.ПроверитьРавенство(0, Поток.ТекущаяПозиция());
	
	// Получим поток только для чтения
	ПотокДляЧтения = Поток.ПолучитьПотокТолькоДляЧтения();
	
	// Проверим, что начальная позиция общая
	юТест.ПроверитьРавенство(0, ПотокДляЧтения.ТекущаяПозиция());
	
	// Прочитаем из основного потока 5 байт - позиция должна сдвинуться в обоих потоках
	БуферЧтения = Новый БуферДвоичныхДанных(5);
	Поток.Прочитать(БуферЧтения, 0, 5);
	
	// Проверим, что позиция изменилась в обоих потоках
	юТест.ПроверитьРавенство(5, Поток.ТекущаяПозиция());
	юТест.ПроверитьРавенство(5, ПотокДляЧтения.ТекущаяПозиция());
	
	// Прочитаем из потока только для чтения еще 3 байта
	БуферЧтения2 = Новый БуферДвоичныхДанных(3);
	ПотокДляЧтения.Прочитать(БуферЧтения2, 0, 3);
	
	// Проверим, что позиция изменилась в обоих потоках
	юТест.ПроверитьРавенство(8, Поток.ТекущаяПозиция());
	юТест.ПроверитьРавенство(8, ПотокДляЧтения.ТекущаяПозиция());
	
	// Проверим, что данные одинаковые - прочитали байты с 6-го по 8-й (значения 6, 7, 8)
	юТест.ПроверитьРавенство(6, БуферЧтения2.Получить(0));
	юТест.ПроверитьРавенство(7, БуферЧтения2.Получить(1));
	юТест.ПроверитьРавенство(8, БуферЧтения2.Получить(2));
	
	// Изменим позицию в потоке только для чтения
	ПотокДляЧтения.Перейти(15, ПозицияВПотоке.Начало);
	
	// Проверим, что позиция изменилась в обоих потоках
	юТест.ПроверитьРавенство(15, Поток.ТекущаяПозиция());
	юТест.ПроверитьРавенство(15, ПотокДляЧтения.ТекущаяПозиция());
	
	// Запишем данные в основной поток (в позицию 15)
	БуферЗаписи = Новый БуферДвоичныхДанных(2);
	БуферЗаписи.Установить(0, 100);
	БуферЗаписи.Установить(1, 200);
	Поток.Записать(БуферЗаписи, 0, 2);
	
	// Позиция должна сдвинуться в обоих потоках
	юТест.ПроверитьРавенство(17, Поток.ТекущаяПозиция());
	юТест.ПроверитьРавенство(17, ПотокДляЧтения.ТекущаяПозиция());
	
	// Вернемся к позиции 15 и прочитаем из потока только для чтения
	ПотокДляЧтения.Перейти(15, ПозицияВПотоке.Начало);
	БуферЧтения3 = Новый БуферДвоичныхДанных(2);
	ПотокДляЧтения.Прочитать(БуферЧтения3, 0, 2);
	
	// Проверим, что мы прочитали измененные данные - данные общие между потоками
	юТест.ПроверитьРавенство(100, БуферЧтения3.Получить(0));
	юТест.ПроверитьРавенство(200, БуферЧтения3.Получить(1));

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

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

	ДвоичныеДанные = ПолучитьДвоичныеДанныеИзHexСтроки("1b1e c416 6a11 c03b 3afe faea 442e 7709");
	Поток = ДвоичныеДанные.ОткрытьПотокДляЧтения();

	Хеширование = Новый ХешированиеДанных(ХешФункция.SHA256);
	Хеширование.Добавить(Поток, 2);
	юТест.ПроверитьРавенство(
		"0b427acd4088d248408e38b34fb378172a05bd71e58b384f5b279beea7aea467",
		НРег(ПолучитьHexСтрокуИзДвоичныхДанных(Хеширование.ХешСумма)));
	юТест.ПроверитьРавенство(2, Поток.ТекущаяПозиция());

	Хеширование.Добавить(Поток, 12);
	юТест.ПроверитьРавенство(
		"2a0815b87888a03406d7ab482b965361eb96112db88e8ab6ea214cb107ee8469",
		НРег(ПолучитьHexСтрокуИзДвоичныхДанных(Хеширование.ХешСумма)));
	юТест.ПроверитьРавенство(14, Поток.ТекущаяПозиция());

	Хеширование.Добавить(Поток, 4);
	юТест.ПроверитьРавенство(
		"817eece1eff577a2d28f1478f496e3880f360611d1f264086fd77cf338464654",
		НРег(ПолучитьHexСтрокуИзДвоичныхДанных(Хеширование.ХешСумма)));
	юТест.ПроверитьРавенство(16, Поток.ТекущаяПозиция());

	Хеширование.Добавить(Поток, 4);
	юТест.ПроверитьРавенство(
		"817eece1eff577a2d28f1478f496e3880f360611d1f264086fd77cf338464654",
		НРег(ПолучитьHexСтрокуИзДвоичныхДанных(Хеширование.ХешСумма)));
	юТест.ПроверитьРавенство(16, Поток.ТекущаяПозиция());

	Хеширование = Новый ХешированиеДанных(ХешФункция.SHA256);
	Поток = ДвоичныеДанные.ОткрытьПотокДляЧтения();
	Поток.Перейти(2, ПозицияВПотоке.Начало);
	Хеширование.Добавить(Поток);
	юТест.ПроверитьРавенство(
		"bda43a0f1c70decfa45d8a2825e6f6facfe0ef11e385794803a165f209b56737",
		НРег(ПолучитьHexСтрокуИзДвоичныхДанных(Хеширование.ХешСумма)));
	юТест.ПроверитьРавенство(16, Поток.ТекущаяПозиция());

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

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

	ДвоичныеДанные = ПолучитьДвоичныеДанныеИзHexСтроки("1b1e c416 6a11 c03b 3afe faea 442e 7709");

	Хеширование = Новый ХешированиеДанных(ХешФункция.SHA256);
	Хеширование.Добавить(ДвоичныеДанные);
	юТест.ПроверитьРавенство(
		"817eece1eff577a2d28f1478f496e3880f360611d1f264086fd77cf338464654",
		НРег(ПолучитьHexСтрокуИзДвоичныхДанных(Хеширование.ХешСумма)));

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

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

	Подстроки = Новый Массив;
	Подстроки.Добавить("Часть1");
	Подстроки.Добавить("Часть2");
	Подстроки.Добавить("Часть3");
	РазделительТекстом = "123";
	
	ТестовыйБуфер = ПолучитьБуферДвоичныхДанныхИзСтроки(СтрСоединить(Подстроки, РазделительТекстом));
	Разделитель = ПолучитьБуферДвоичныхДанныхИзСтроки(РазделительТекстом);

	РазделенныеДанные = ТестовыйБуфер.Разделить(Разделитель);

	юТест.ПроверитьРавенство(РазделенныеДанные.Количество(), 3, "два разделителя - три элемента");

	Для Инд = 0 По Подстроки.ВГраница() Цикл

		СтрокаИзБуфера = ПолучитьСтрокуИзБуфераДвоичныхДанных(РазделенныеДанные[Инд]);
		юТест.ПроверитьРавенство(СтрокаИзБуфера, Подстроки[Инд], "сравнение строк после разделения буфера");

	КонецЦикла;

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

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

	Подстроки = Новый Массив;
	Подстроки.Добавить("Часть1");
	Подстроки.Добавить("Часть2");
	Подстроки.Добавить("Часть3");
	Подстроки.Добавить("Часть4");
	Подстроки.Добавить("Часть5");
	
	ТестоваяСтрока = "Часть1\R\R\NЧасть2\R\NЧасть3\NЧасть4\RЧасть5";
	
	ТестовыйБуфер = ПолучитьБуферДвоичныхДанныхИзСтроки(ТестоваяСтрока);
	Разделители = Новый Массив;
	Разделители.Добавить(ПолучитьБуферДвоичныхДанныхИзСтроки("\N"));
	Разделители.Добавить(ПолучитьБуферДвоичныхДанныхИзСтроки("\R\N"));
	Разделители.Добавить(ПолучитьБуферДвоичныхДанныхИзСтроки("\R"));
	Разделители.Добавить(ПолучитьБуферДвоичныхДанныхИзСтроки("\R\R\N"));
	
	РазделенныеДанные = ТестовыйБуфер.Разделить(Разделители);
	
	юТест.ПроверитьРавенство(РазделенныеДанные.Количество(), 5);
	
	Для Инд = 0 По РазделенныеДанные.ВГраница() Цикл
		
		СтрокаИзБуфера = ПолучитьСтрокуИзБуфераДвоичныхДанных(РазделенныеДанные[Инд]);
		юТест.ПроверитьРавенство(СтрокаИзБуфера, Подстроки[Инд], "сравнение строк после разделения буфера");
		
	КонецЦикла;

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

Процедура ТестДолжен_ПроверитьЧтоПрочитатьБайтНеВыбрасываетИсключениеВКонцеПотока() Экспорт
    
    Буфер = ПолучитьБуферСДанными();
    Буфер.УстановитьТолькоЧтение();
    Поток = Новый ПотокВПамяти(Буфер);
    ЧтениеДанных = Новый ЧтениеДанных(Поток.ЗакрытьИПолучитьДвоичныеДанные());
    
    Сч = 0;
    Пока Сч <= Буфер.Размер Цикл // читаем после конца буфера
    
        Байт = ЧтениеДанных.ПрочитатьБайт();
        Если Байт = Неопределено Тогда
            Прервать; // должны зайти сюда
        КонецЕсли;
        
        Сч = Сч + 1;
            
    КонецЦикла;
КонецПроцедуры