Skip to content
TheChatArchiveThe Chat Archive
Geminigemini-2.5-pro· GoogleHugging Face LMArena Human Preference 140K

Dostosuj nazewnictwo do poniższego początku pliku:

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Metallama-4-maverick-17b-128e-instruct’s answer.
  1. User

    Dostosuj nazewnictwo do poniższego początku pliku:

  2. Gemini Assistant

    Jasne, oto pełny plik z testami dostosowany do podanej struktury i nazewnictwa plików.

    Główne zmiany to:

    1. Dodanie #include "pch.h" na początku.
    2. Zmiana ścieżki do pliku nagłówkowego na #include "../IntervalExtractor/IntervalExtractor.h", zgodnie z typową strukturą projektów w Visual Studio, gdzie projekt testowy jest w innym folderze niż testowany kod.

    Reszta logiki testów pozostaje bez zmian.

    #include "pch.h"
    #include "CppUnitTest.h"
    #include "../IntervalExtractor/IntervalExtractor.h" // Dostosowana ścieżka
    #include <vector>
    
    using namespace Microsoft::VisualStudio::CppUnitTestFramework;
    
    // Klasa pomocnicza do testowania prywatnych metod IntervalExtractor.
    // Jest to możliwe, ponieważ w pliku nagłówkowym IntervalExtractor.h
    // zadeklarowano `friend class IntervalExtractorPrivateTests;`.
    class IntervalExtractorPrivateTests {
    public:
        static float TestTrapezoidalMethod(IntervalExtractor& extractor, int startIndex, int length) {
            return extractor.trapezoidalMethod(startIndex, length);
        }
    };
    
    namespace IntervalExtractorUnitTests
    {
        TEST_CLASS(TrapezoidalMethodTests)
        {
        public:
            
            // Testuje podstawowy przypadek: pojedynczy przedział całkowania.
            TEST_METHOD(Trapezoidal_SingleInterval_CalculatesCorrectly)
            {
                // Arrange
                std::vector<float> y = {2.0f, 3.0f};
                std::vector<float> t = {0.0f, 1.0f};
                IntervalExtractor extractor(y, IntervalExtractor::EnergyMethod::TRAPEZOIDAL_METHOD, t);
                
                // Act
                float energy = IntervalExtractorPrivateTests::TestTrapezoidalMethod(extractor, 0, 1);
                
                // Assert: 0.5 * (2+3) * 1 = 2.5
                Assert::AreEqual(2.5f, energy, 0.001f);
            }
            
            // Testuje sumowanie energii z wielu przedziałów.
            TEST_METHOD(Trapezoidal_MultipleIntervals_CalculatesCorrectSum)
            {
                // Arrange
                std::vector<float> y = {2.0f, 3.0f, 4.0f, 5.0f};
                std::vector<float> t = {0.0f, 1.0f, 2.0f, 3.0f};
                IntervalExtractor extractor(y, IntervalExtractor::EnergyMethod::TRAPEZOIDAL_METHOD, t);
                
                // Act
                float energy = IntervalExtractorPrivateTests::TestTrapezoidalMethod(extractor, 0, 3);
                
                // Assert: 0.5 * [(2+3)*1 + (3+4)*1 + (4+5)*1] = 0.5 * 21 = 10.5
                Assert::AreEqual(10.5f, energy, 0.001f);
            }
            
            // Testuje działanie metody z nierównymi odstępami czasowymi.
            TEST_METHOD(Trapezoidal_NonUniformTimeIntervals_CalculatesCorrectly)
            {
                // Arrange
                std::vector<float> y = {2.0f, 3.0f, 4.0f, 5.0f};
                std::vector<float> t = {0.0f, 1.0f, 3.0f, 6.0f};
                IntervalExtractor extractor(y, IntervalExtractor::EnergyMethod::TRAPEZOIDAL_METHOD, t);
                
                // Act
                float energy = IntervalExtractorPrivateTests::TestTrapezoidalMethod(extractor, 0, 3);
                
                // Assert: 0.5 * [(2+3)*1 + (3+4)*2 + (4+5)*3] = 0.5 * 46 = 23.0
                Assert::AreEqual(23.0f, energy, 0.001f);
            }
            
            // Testuje przypadek, gdy wszystkie wartości y są zerowe.
            TEST_METHOD(Trapezoidal_ZeroValues_ReturnsZero)
            {
                // Arrange
                std::vector<float> y = {0.0f, 0.0f, 0.0f, 0.0f};
                std::vector<float> t = {0.0f, 1.0f, 2.0f, 3.0f};
                IntervalExtractor extractor(y, IntervalExtractor::EnergyMethod::TRAPEZOIDAL_METHOD, t);
                
                // Act
                float energy = IntervalExtractorPrivateTests::TestTrapezoidalMethod(extractor, 0, 3);
                
                // Assert
                Assert::AreEqual(0.0f, energy, 0.001f);
            }
            
            // Testuje działanie metody z ujemnymi wartościami y.
            TEST_METHOD(Trapezoidal_NegativeValues_CalculatesCorrectNegativeEnergy)
            {
                // Arrange
                std::vector<float> y = {-2.0f, -3.0f, -4.0f, -5.0f};
                std::vector<float> t = {0.0f, 1.0f, 2.0f, 3.0f};
                IntervalExtractor extractor(y, IntervalExtractor::EnergyMethod::TRAPEZOIDAL_METHOD, t);
                
                // Act
                float energy = IntervalExtractorPrivateTests::TestTrapezoidalMethod(extractor, 0, 3);
                
                // Assert: 0.5 * [(-2-3)*1 + (-3-4)*1 + (-4-5)*1] = 0.5 * -21 = -10.5
                Assert::AreEqual(-10.5f, energy, 0.001f);
            }
            
            // Testuje działanie z mieszanymi (dodatnimi i ujemnymi) wartościami y.
            TEST_METHOD(Trapezoidal_MixedSignValues_CalculatesCorrectly)
            {
                // Arrange
                std::vector<float> y = {-2.0f, 3.0f, -4.0f, 5.0f};
                std::vector<float> t = {0.0f, 1.0f, 2.0f, 3.0f};
                IntervalExtractor extractor(y, IntervalExtractor::EnergyMethod::TRAPEZOIDAL_METHOD, t);
                
                // Act
                float energy = IntervalExtractorPrivateTests::TestTrapezoidalMethod(extractor, 0, 3);
                
                // Assert: 0.5 * [(-2+3)*1 + (3-4)*1 + (-4+5)*1] = 0.5 * (1 - 1 + 1) = 0.5
                Assert::AreEqual(0.5f, energy, 0.001f);
            }
            
            // Testuje przypadek brzegowy, gdy długość przedziału (length) wynosi 0.
            TEST_METHOD(Trapezoidal_ZeroLengthInterval_ReturnsZero)
            {
                // Arrange
                std::vector<float> y = {2.0f, 3.0f, 4.0f, 5.0f};
                std::vector<float> t = {0.0f, 1.0f, 2.0f, 3.0f};
                IntervalExtractor extractor(y, IntervalExtractor::EnergyMethod::TRAPEZOIDAL_METHOD, t);
                
                // Act
                float energy = IntervalExtractorPrivateTests::TestTrapezoidalMethod(extractor, 0, 0);
                
                // Assert
                Assert::AreEqual(0.0f, energy, 0.001f);
            }
            
            // Testuje przypadek funkcji stałej. Wynik powinien być taki sam jak pole prostokąta.
            TEST_METHOD(Trapezoidal_ConstantFunction_ReturnsCorrectArea)
            {
                // Arrange
                std::vector<float> y = {5.0f, 5.0f, 5.0f, 5.0f};
                std::vector<float> t = {0.0f, 1.0f, 2.0f, 3.0f};
                IntervalExtractor extractor(y, IntervalExtractor::EnergyMethod::TRAPEZOIDAL_METHOD, t);
                
                // Act
                float energy = IntervalExtractorPrivateTests::TestTrapezoidalMethod(extractor, 0, 3);
                
                // Assert: 0.5*[(5+5)*1 + (5+5)*1 + (5+5)*1] = 15. Pole prostokąta: 5 * 3 = 15.
                Assert::AreEqual(15.0f, energy, 0.001f);
            }
            
            // Testuje funkcję liniową, dla której metoda trapezów daje wynik dokładny.
            TEST_METHOD(Trapezoidal_LinearFunction_ReturnsExactIntegral)
            {
                // Arrange: f(x)=2x+1. Całka od 0 do 3 to [x^2+x] = 12.
                std::vector<float> y = {1.0f, 3.0f, 5.0f, 7.0f}; // y dla x = 0,1,2,3
                std::vector<float> t = {0.0f, 1.0f, 2.0f, 3.0f};
                IntervalExtractor extractor(y, IntervalExtractor::EnergyMethod::TRAPEZOIDAL_METHOD, t);
                
                // Act
                float energy = IntervalExtractorPrivateTests::TestTrapezoidalMethod(extractor, 0, 3);
                
                // Assert: 0.5*[(1+3)*1 + (3+5)*1 + (5+7)*1] = 0.5*24 = 12.
                Assert::AreEqual(12.0f, energy, 0.001f);
            }
            
            // Testuje obliczanie energii dla fragmentu (pod-interwału) danych.
            TEST_METHOD(Trapezoidal_SubInterval_CalculatesCorrectPartialEnergy)
            {
                // Arrange
                std::vector<float> y = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f};
                std::vector<float> t = {0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f};
                IntervalExtractor extractor(y, IntervalExtractor::EnergyMethod::TRAPEZOIDAL_METHOD, t);
                
                // Act: Oblicz energię dla fragmentu od indeksu 2 o długości 2 (wartości: 3,4,5)
                float energy = IntervalExtractorPrivateTests::TestTrapezoidalMethod(extractor, 2, 2);
                
                // Assert: 0.5 * [(3+4)*1 + (4+5)*1] = 0.5 * 16 = 8.0
                Assert::AreEqual(8.0f, energy, 0.001f);
            }
        };
    }
    

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.