GoogleTest: het overslaan van een test?

Met Behulp Van Google Test 1.6 (Windows 7, Visual Studio C++). Hoe zet ik een bepaalde test? (aka hoe kan ik voorkomen dat er een test wordt uitgevoerd). Is er iets wat ik kan doen naast het commentaar uit de hele test?

InformationsquelleAutor User | 2011-08-26

 

8 Replies
  1. 143

    De documenten voor Google Test 1.7 voorstellen:

    “Als je een gebroken test dat u niet kunt oplossen meteen, u kunt de DISABLED_ voorvoegsel voor de naam. Dit zal uitsluiten van uitvoering.”

    Voorbeelden:

    //Tests that Foo does Abc.
    TEST(FooTest, DISABLED_DoesAbc) { ... }
    
    class DISABLED_BarTest : public ::testing::Test { ... };
    
    //Tests that Bar does Xyz.
    TEST_F(DISABLED_BarTest, DoesXyz) { ... }
    
    • vond het ook en filters
    • Ik vond het net voordat u boekt uw reactie… (en ik zet het zo een antwoord te). Vervolgens heb ik mijn reactie verwijderd, het uitzoeken van het verouderde… maar dat is een aantal echt goede info! +1
  2. 63

    U kunt ook het uitvoeren van een subset van tests, volgens de documentatie:

    Het uitvoeren van een Subset van de Tests

    Standaard een Google-Test programma alle tests die de gebruiker heeft gedefinieerd.
    Soms wilt u alleen een subset van de tests (bv. voor
    probleemoplossing of voor het snel controleren van een verandering). Als u de GTEST_FILTER
    omgevingsvariabele of de –gtest_filter vlag van een filter,
    Google Test zal alleen het uitvoeren van de tests waarvan de volledige namen (in de vorm van
    TestCaseName.TestName) overeenkomen met het filter.

    Het formaat van een filter is een ‘:’-gescheiden lijst van jokertekens
    (de positieve patronen) eventueel gevolgd door een ‘-‘ en
    een ander ‘: ‘gescheiden patroon lijst (de zogenaamde negatieve patronen). Een
    test overeenkomen met het filter als en slechts als het overeenkomt met een van de positieve
    patronen, maar met geen van de negatieve patronen.

    Een patroon kan bevatten ‘*’ (komt overeen met een tekenreeks) of ‘?’ (komt overeen met een
    enkel teken). Voor het gemak is het filter ‘*-NegativePatterns’
    kan ook worden geschreven als ‘-NegativePatterns’.

    Bijvoorbeeld:

    ./foo_test Has no flag, and thus runs all its tests.
    ./foo_test --gtest_filter=* Also runs everything, due to the single match-everything * value.
    ./foo_test --gtest_filter=FooTest.* Runs everything in test case FooTest.
    ./foo_test --gtest_filter=*Null*:*Constructor* Runs any test whose full name contains either "Null" or "Constructor".
    ./foo_test --gtest_filter=-*DeathTest.* Runs all non-death tests.
    ./foo_test --gtest_filter=FooTest.*-FooTest.Bar Runs everything in test case FooTest except FooTest.Bar. 
    

    Niet de mooiste oplossing, maar het werkt.

  3. 16

    Hier is de uitdrukking te zijn tests waarvan de namen van de snaren foo1 of foo2 in hen en uitsluiten van tests waarvan de namen van de snaren bar1 of bar2 in hen:

    --gtest_filter=*foo1*:*foo2*-*bar1*:*bar2*
    
  4. 9

    Ik geef de voorkeur om het te doen in de code:

    //Run a specific test only
    //testing::GTEST_FLAG(filter) = "MyLibrary.TestReading"; //I'm testing a new feature, run something quickly
    
    //Exclude a specific test
    testing::GTEST_FLAG(filter) = "-MyLibrary.TestWriting"; //The writing test is broken, so skip it
    

    Kan ik het commentaar van beide lijnen om alle tests uit te voeren, opmerkingen uit de eerste lijn aan het testen van een enkele functie die ben ik aan het onderzoeken/werken, of opmerkingen van de tweede lijn indien een test is gebroken, maar ik wil de test alles anders.

    U kunt ook testen/uitsluiten van een suite van functies met behulp van jokertekens en het schrijven van een lijst, “MyLibrary.TestNetwork*” of “-MyLibrary.TestFileSystem*”.

    • Dit is een geweldige oplossing. Ik gebruik het uitsluiten van een aantal tests standaard als het filter is leeg. Ze kunnen worden ingeschakeld met export GTEST_FILTER='*'.
    • Eigenlijk is dat niet omdat de standaard is “*” niet”. In plaats daarvan ik gebruik gewoon een andere omgevingsvariabele wordt overschreven door de filter.
    • Waar heb je het definiëren van de “filter”? Is het een string ?
    • Ik heb het niet definiëren, dus ik denk dat het moet een globale opgenomen van gtest/gtest.h?
  5. 9

    U kunt nu gebruik maken van de GTEST_SKIP() macro voorwaardelijk overslaan van een test tijdens de uitvoering. Bijvoorbeeld:

    TEST(Foo, Bar)
    {
        if (blah)
            GTEST_SKIP();
    
        ...
    }
    

    Let op dit is een zeer recente functie dus je kan nodig zijn voor het bijwerken van uw GoogleTest bibliotheek te gebruiken.

    • Deze functie is nog niet vrijgegeven. Het is onwaarschijnlijk dat zij zullen worden opgenomen in een 1.8.x tak, omdat alleen de correcties worden geaccepteerd daar. 1.9 is nog niet beschikbaar, zelfs niet aangekondigd op dit moment.
  6. 5

    Als er meer dan één test nodig zijn worden overgeslagen

    --gtest_filter=-TestName.*:TestName.*TestCase
    
  7. 4

    Voor een andere aanpak, kunt u wikkel je testen in een functie en gebruik normaal voorwaardelijke controles tijdens runtime om alleen uit te voeren als u wilt.

    #include <gtest/gtest.h>
    
    const bool skip_some_test = true;
    
    bool some_test_was_run = false;
    
    void someTest() {
       EXPECT_TRUE(!skip_some_test);
       some_test_was_run = true;
    }
    
    TEST(BasicTest, Sanity) {
       EXPECT_EQ(1, 1);
       if(!skip_some_test) {
          someTest();
          EXPECT_TRUE(some_test_was_run);
       }
    }
    

    Dit is handig voor mij als ik probeer om een aantal testen uitvoeren alleen wanneer een systeem ondersteunt IPv6 dual stack.

    Technisch dat dualstack spullen niet echt een unit test het afhankelijk is van het systeem. Maar ik kan niet echt een integratie testen tot ik testte ze toch het werk en dit zorgt ervoor dat het niet melden storingen wanneer het niet de fout codes.

    Als voor het testen van het programma heb ik een stub objecten die het simuleren van een systeem ondersteuning voor dualstack (of gebrek aan) door de aanleg van valse aansluitingen.

    Het enige nadeel is dat de test output en het aantal tests zal wijzigen, hetgeen kan leiden tot problemen met iets dat monitoren van het aantal succesvolle tests.

    U kunt ook gebruik maken van ASSERT_* in plaats van EQUAL_*. Doen gelden, zal de rest van de test als het niet lukt. Voorkomt een hoop overbodige spullen dumpen op de console.

  8. 4

    Ik had het nodig voor voorwaardelijke tests, en ik bedacht een goede oplossing. Ik gedefinieerde macro TEST_C dat werkt als een TEST_F macro, maar het is de derde parameter, die een boolean expressie geëvalueerd runtime in main.cpp VOOR de tests worden gestart. Testen voor het evalueren van vals zijn niet uitgevoerd. De macro is lelijk, maar het lijkt:

    #pragma once
    extern std::map<std::string, std::function<bool()> >* m_conditionalTests;
    #define TEST_C(test_fixture, test_name, test_condition)\
    class test_fixture##_##test_name##_ConditionClass\
    {\
        public:\
        test_fixture##_##test_name##_ConditionClass()\
        {\
            std::string name = std::string(#test_fixture) + "." + std::string(#test_name);\
            if (m_conditionalTests==NULL) {\
                m_conditionalTests = new std::map<std::string, std::function<bool()> >();\
            }\
            m_conditionalTests->insert(std::make_pair(name, []()\
            {\
                DeviceInfo device = Connection::Instance()->GetDeviceInfo();\
                return test_condition;\
            }));\
        }\
    } test_fixture##_##test_name##_ConditionInstance;\
    TEST_F(test_fixture, test_name)
    

    Bovendien, in uw main.cpp u moet deze lus te sluiten van de testen voor het evalueren van false:

    //identify tests that cannot run on this device
    std::string excludeTests;
    for (const auto& exclusion : *m_conditionalTests)
    {
        bool run = exclusion.second();
        if (!run)
        {
            excludeTests += ":" + exclusion.first;
        }
    }
    
    //add the exclusion list to gtest
    std::string str = ::testing::GTEST_FLAG(filter);
    ::testing::GTEST_FLAG(filter) = str + ":-" + excludeTests;
    
    //run all tests
    int result = RUN_ALL_TESTS();
    
    • Hoe heb je de definitie van “filter” in de std::string str = ::testen::GTEST_FLAG(filter);?

Geef een reactie

Het e-mailadres wordt niet gepubliceerd. Vereiste velden zijn gemarkeerd met *