test_streams.cpp - master - annabasalyga/Traffic_simulator

test_streams.cpp
452 строки14 KB
Anna
Histogram and box was modified
19 янв 2026, 22:34
19 янв 2026, 22:3425dae28
//// tests.cpp
//#include <iostream>
//#include <memory>
//#include <string>
//#include <vector>
//#include <cassert>
//#include <cmath>
//
//// ���������� ���� ������
//#include "sequence.h"
//#include "lazy_sequence.h"
//#include "stream.h"
//
//// ��������������� ������� ��� ������
//void test_sequence() {
//    std::cout << "Testing Sequence (abstract interface)...\n";
//
//    // ���� ����� LazySequence (���������� Sequence)
//    int data[] = { 1, 2, 3 };
//    LazySequence<int> seq(data, 3);
//
//    assert(seq.GetLength() == 3);
//    assert(seq.Get(0) == 1);
//    assert(seq.Get(1) == 2);
//    assert(seq.Get(2) == 3);
//
//    std::cout << "Sequence tests PASSED\n\n";
//}
//
//void test_lazy_sequence() {
//    std::cout << "Testing LazySequence...\n";
//
//    // ���� 1: �������� �� �������
//    int data[] = { 10, 20, 30 };
//    LazySequence<int> lazy1(data, 3);
//
//    assert(lazy1.GetLength() == 3);
//    assert(lazy1.Get(0) == 10);
//    assert(lazy1.Get(1) == 20);
//    assert(lazy1.Get(2) == 30);
//
//    // ���� 2: �������� ����� ���������
//    int counter = 0;
//    auto gen = [&counter](Sequence<int>* seq) -> int {
//        return ++counter;
//        };
//    LazySequence<int> lazy2(gen);
//
//    assert(lazy2.Get(0) == 1);
//    assert(lazy2.Get(1) == 2);
//    assert(lazy2.Get(2) == 3);
//
//    // ���� 3: ����������� ������������������
//    assert(lazy2.GetLength() == -1);  // -1 �������� �������������
//
//    // ���� 4: ��������� ���������������������
//    LazySequence<int>* subseq = dynamic_cast<LazySequence<int>*>(lazy1.GetSubsequence(1, 2));
//    if (subseq) {
//        assert(subseq->GetLength() == 2);
//        assert(subseq->Get(0) == 20);
//        assert(subseq->Get(1) == 30);
//        delete subseq;
//    }
//
//    std::cout << "LazySequence tests PASSED\n\n";
//}
//
//void test_deserializers() {
//    std::cout << "Testing Deserializers...\n";
//
//    // ���� StringDeserializer
//    StringDeserializer strDes;
//    std::string strTest = "Hello";
//    std::string serializedStr = strDes.ToString(strTest);
//    std::string deserializedStr = strDes.FromString(serializedStr);
//    assert(deserializedStr == "Hello");
//
//    // ���� IntDeserializer
//    IntDeserializer intDes;
//    int intTest = 42;
//    std::string serializedInt = intDes.ToString(intTest);
//    int deserializedInt = intDes.FromString(serializedInt);
//    assert(deserializedInt == 42);
//
//    // ���� DoubleDeserializer
//    DoubleDeserializer doubleDes;
//    double doubleTest = 3.14159;
//    std::string serializedDouble = doubleDes.ToString(doubleTest);
//    double deserializedDouble = doubleDes.FromString(serializedDouble);
//    assert(std::abs(deserializedDouble - 3.14159) < 0.0001);
//
//    std::cout << "Deserializers tests PASSED\n\n";
//}
//
//void test_read_only_stream() {
//    std::cout << "Testing ReadOnlyStream...\n";
//
//    // ���� 1: ����� �� LazySequence
//    int seqData[] = { 100, 200, 300 };
//    LazySequence<int> seq(seqData, 3);
//
//    ReadOnlyStream<int> stream1(&seq);
//    stream1.Open();
//
//    assert(stream1.Read() == 100);
//    assert(stream1.Read() == 200);
//    assert(stream1.Read() == 300);
//    assert(stream1.IsEndOfStream());
//
//    // ���� 2: Seek
//    stream1.Seek(1);
//    assert(stream1.Read() == 200);
//
//    // ���� 3: TryRead
//    stream1.Seek(2);
//    auto value = stream1.TryRead();
//    assert(value.has_value());
//    assert(value.value() == 300);
//
//    auto noValue = stream1.TryRead();
//    assert(!noValue.has_value());
//
//    stream1.Close();
//
//    // ���� 4: ����� �� �����
//    try {
//        auto intDes = std::make_shared<IntDeserializer>();
//        ReadOnlyStream<int> fileStream("test_input.txt", intDes, true);
//        fileStream.Open();
//        std::cout << "File stream opened successfully\n";
//
//        std::cout << "IsEndOfStream before reading: " << (fileStream.IsEndOfStream() ? "true" : "false") << std::endl;
//
//        // ������ ��������� ��������
//        std::cout << "Reading first value...\n";
//        int val1 = fileStream.Read();
//        std::cout << "First value read: " << val1 << "\n";
//
//        std::cout << "IsEndOfStream after first read: "
//            << (fileStream.IsEndOfStream() ? "true" : "false") << "\n";
//
//        std::cout << "Reading second value...\n";
//        int val2 = fileStream.Read();
//        std::cout << "Second value read: " << val2 << "\n";
//
//        std::cout << "IsEndOfStream after second read: "
//            << (fileStream.IsEndOfStream() ? "true" : "false") << "\n";
//
//        std::cout << "Read from file: " << val1 << ", " << val2 << "\n";
//
//        // ������� ��������� ���, �� ����� TryRead
//        auto val3 = fileStream.TryRead();
//        if (val3.has_value()) {
//            std::cout << "Third value: " << val3.value() << "\n";
//        }
//        else {
//            std::cout << "No third value (expected)\n";
//        }
//
//        fileStream.Close();
//        std::cout << "File stream test PASSED\n";
//    }
//    catch (const StreamException& e) {
//        std::cout << "File stream test FAILED: " << e.what() << "\n";
//        throw;  // ������������� ����������
//    }
//    catch (const std::exception& e) {
//        std::cout << "Unexpected error in file stream test: " << e.what() << "\n";
//        throw;
//    }
//
//    // ���� 5: ����� �� ������
//    std::cout << "\nTesting string stream...\n";
//    try {
//        auto intDes = std::make_shared<IntDeserializer>();
//        ReadOnlyStream<int> stringStream("10\n20\n30", intDes);  // ��� \n � �����!
//        stringStream.Open();
//
//        std::cout << "Reading first value from string...\n";
//        assert(stringStream.Read() == 10);
//        std::cout << "First value OK\n";
//
//        std::cout << "Reading second value from string...\n";
//        assert(stringStream.Read() == 20);
//        std::cout << "Second value OK\n";
//
//        std::cout << "Reading third value from string...\n";
//        assert(stringStream.Read() == 30);
//        std::cout << "Third value OK\n";
//
//        std::cout << "Checking end of stream...\n";
//        // ����� ������ 3 �������� ����� ������ ���� ����
//        assert(stringStream.IsEndOfStream());
//        std::cout << "End of stream correctly detected\n";
//
//        // ������� ��������� ����� ����� - ������ ������� nullopt
//        auto extra = stringStream.TryRead();
//        assert(!extra.has_value());
//        std::cout << "TryRead after end returns nullopt (correct)\n";
//
//        stringStream.Close();
//        std::cout << "String stream test PASSED\n";
//    }
//    catch (const std::exception& e) {
//        std::cout << "String stream test FAILED: " << e.what() << "\n";
//        throw;
//    }
//
//    std::cout << "ReadOnlyStream tests PASSED\n\n";
//}
//
//void test_write_only_stream() {
//    std::cout << "Testing WriteOnlyStream...\n";
//
//    // ���� 1: ����� � LazySequence (����� Sequence ���������)
//    int bufferData[] = { 0, 0, 0 };
//    LazySequence<int> seq(bufferData, 0); // ������ ������������������
//
//    WriteOnlyStream<int> stream1(&seq);
//
//    assert(stream1.Write(10) == 1);
//    assert(stream1.Write(20) == 2);
//    assert(stream1.Write(30) == 3);
//
//    stream1.Flush();
//    // ����������: LazySequence �� ������������ Append � ������� ����������
//    // ���� ��������� ������ ��� ������ �� ������ � �����������
//
//    // ���� 2: ����� � ����
//    try {
//        auto intDes = std::make_shared<IntDeserializer>();
//        WriteOnlyStream<int> fileStream("test_output.txt", intDes);
//        fileStream.Open();
//
//        assert(fileStream.Write(42) == 1);
//        assert(fileStream.Write(99) == 2);
//        assert(fileStream.Write(777) == 3);
//
//        fileStream.Flush();
//        fileStream.Close();
//
//        std::cout << "File written successfully\n";
//    }
//    catch (const StreamException& e) {
//        std::cout << "File write test failed: " << e.what() << "\n";
//    }
//
//    // ���� 3: ������� �������
//    int targetData[] = { 0, 0 };
//    LazySequence<int> targetSeq(targetData, 0);
//    WriteOnlyStream<int> targetStream(&targetSeq);
//    WriteOnlyStream<int> chainStream(targetStream);
//
//    chainStream.Write(1000);
//    chainStream.Write(2000);
//    chainStream.Flush();
//
//    // ���� 4: ����� � ������ (����������� �� ���������)
//    WriteOnlyStream<int> memoryStream;
//    memoryStream.Write(1);
//    memoryStream.Write(2);
//    memoryStream.Write(3);
//
//    assert(memoryStream.GetPosition() == 3);
//
//    std::cout << "WriteOnlyStream tests PASSED\n\n";
//}
//
//void test_stream_base() {
//    std::cout << "Testing StreamBase functionality...\n";
//
//    int data[] = { 1, 2 };
//    LazySequence<int> seq(data, 2);
//
//    ReadOnlyStream<int> stream(&seq);
//
//    // ���� ������� �������
//    assert(!stream.IsOpen());
//    stream.Open();
//    assert(stream.IsOpen());
//
//    assert(stream.GetPosition() == 0);
//    stream.Read();
//    assert(stream.GetPosition() == 1);
//
//    assert(stream.IsCanSeek());  // LazySequence ������������ Seek
//
//    stream.Close();
//    assert(!stream.IsOpen());
//
//    std::cout << "StreamBase tests PASSED\n\n";
//}
//
//void test_exceptions() {
//    std::cout << "Testing Exceptions...\n";
//
//    // ���� 1: ������ �� ��������� ������
//    try {
//        int data[] = { 1 };
//        LazySequence<int> seq(data, 1);
//        ReadOnlyStream<int> stream(&seq);
//        stream.Read();  // ������ ������� ����������
//        assert(false);  // �� ������ ���� �����
//    }
//    catch (const StreamOperationException& e) {
//        std::cout << "Correctly caught: " << e.what() << "\n";
//    }
//
//    // ���� 2: ������ � �������� �����
//    try {
//        int data[] = { 0 };
//        LazySequence<int> seq(data, 0);
//        WriteOnlyStream<int> stream(&seq);
//        stream.Close();
//        stream.Write(1);  // ������ ������� ����������
//        assert(false);
//    }
//    catch (const StreamOperationException& e) {
//        std::cout << "Correctly caught: " << e.what() << "\n";
//    }
//
//    // ���� 3: ������ �� ��������� ������
//    try {
//        int data[] = { 1 };
//        LazySequence<int> seq(data, 1);
//        ReadOnlyStream<int> stream(&seq);
//        stream.Open();
//        stream.Read();  // 1
//        stream.Read();  // ������ ������� EndOfStreamException
//        assert(false);
//    }
//    catch (const EndOfStreamException& e) {
//        std::cout << "Correctly caught EndOfStream: " << e.what() << "\n";
//    }
//
//    // ���� 4: ������������ �����������
//    try {
//        WriteOnlyStream<int> stream(static_cast<Sequence<int>*>(nullptr));
//        assert(false);
//    }
//    catch (const StreamOperationException& e) {
//        std::cout << "Correctly caught null sequence: " << e.what() << "\n";
//    }
//
//    std::cout << "Exception tests PASSED\n\n";
//}
//
//void test_integration() {
//    std::cout << "Testing Integration...\n";
//
//    // ������� �������� ������
//    int sourceData[] = { 10, 20, 30, 40, 50 };
//    LazySequence<int> sourceSeq(sourceData, 5);
//
//    // ������ �� ������������������
//    ReadOnlyStream<int> reader(&sourceSeq);
//    reader.Open();
//
//    // ����� � ����
//    try {
//        auto intDes = std::make_shared<IntDeserializer>();
//        WriteOnlyStream<int> writer("integration_test.txt", intDes);
//        writer.Open();
//
//        // �������� ������
//        while (!reader.IsEndOfStream()) {
//            int value = reader.Read();
//            writer.Write(value);
//        }
//        writer.Flush();
//        writer.Close();
//
//        // ������ ������� �� �����
//        ReadOnlyStream<int> fileReader("integration_test.txt", intDes, true);
//        fileReader.Open();
//
//        // ���������
//        fileReader.Seek(0);
//        assert(fileReader.Read() == 10);
//        assert(fileReader.Read() == 20);
//        assert(fileReader.Read() == 30);
//
//        fileReader.Close();
//
//        std::cout << "Integration test PASSED (file roundtrip)\n";
//
//    }
//    catch (const StreamException& e) {
//        std::cout << "Integration test skipped (file error): " << e.what() << "\n";
//    }
//
//    reader.Close();
//
//    std::cout << "Integration test COMPLETED\n\n";
//}
//
//void test_stream_chaining() {
//    std::cout << "Testing Stream Chaining...\n";
//
//    // ������� �������: stream1 -> stream2 -> stream3
//    int data[] = { 0 };
//    LazySequence<int> finalTarget(data, 0);
//
//    WriteOnlyStream<int> stream3(&finalTarget);
//    WriteOnlyStream<int> stream2(stream3);
//    WriteOnlyStream<int> stream1(stream2);
//
//    stream1.Write(100);
//    stream1.Write(200);
//    stream1.Flush();
//
//    stream2.Write(300);
//    stream2.Flush();
//
//    stream3.Write(400);
//    stream3.Flush();
//
//    // ��� ������ ������ ������� � finalTarget
//    // (���� LazySequence ������������ Append)
//
//    std::cout << "Stream chaining test COMPLETED\n\n";
//}
//
//int test_streams() {
//    std::cout << "=== Starting Stream Library Tests ===\n\n";
//
//    try {
//        test_sequence();
//        test_lazy_sequence();
//        test_deserializers();
//        test_read_only_stream();
//        test_write_only_stream();
//        test_stream_base();
//        test_exceptions();
//        test_integration();
//        test_stream_chaining();
//
//        std::cout << "=== ALL TESTS PASSED ===\n";
//        return 0;
//
//    }
//    catch (const std::exception& e) {
//        std::cerr << "\n=== TEST FAILED ===\n";
//        std::cerr << "Error: " << e.what() << "\n";
//        return 1;
//    }
//    catch (...) {
//        std::cerr << "\n=== TEST FAILED ===\n";
//        std::cerr << "Unknown error\n";
//        return 1;
//    }
//}