Перем юТест;

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

юТест = ЮнитТестирование;

ВсеТесты = Новый Массив;

ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоСоздаетсяБуферДвоичныхДанных");

ВсеТесты.Добавить("ТестДолжен_ПроверитьРазделениеБуфераДвоичныхДанныхНесколькимиБуферами");

ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоМожноЗаписатьБайты");

ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоМожноПрочитатьБайты");

ВсеТесты.Добавить("ТестДолжен_ПроверитьЧтоМожноЗаписатьПрочитатьЦелое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;

КонецЦикла;