Loading ...
Sorry, an error occurred while loading the content.
 

More on Unit Testing

Expand Messages
  • nyrb2
    Thank you so much for all your responses! As a developer, I find the input invaluable in trying to formulate a plan for testing and I appreciate all your
    Message 1 of 11 , Feb 18, 2010
      Thank you so much for all your responses! As a developer, I find the input invaluable in trying to formulate a plan for testing and I appreciate all your collective years of experience.

      What are your thoughts on "end-to-end" tests? Tests that don't examine the operability of various pieces of a function, but test the entire function as a whole? Our software lead was pretty insistent that we write these kind of tests in addition to unit tests so that the functionality can be placed into an "automated test" framework. The problem is, as I said in my previous post, the prospect of writing an end-to-end test even for something relatively simple such as this "delete" function is rather daunting.
    • Olof Bjarnason
      2010/2/19 nyrb2 ... of writing one yet for the legacy project I m on, but I ve thought a lot on how to achieve it. However, what
      Message 2 of 11 , Feb 20, 2010
        2010/2/19 nyrb2 <ua485@...>

        >
        >
        > Thank you so much for all your responses! As a developer, I find the input
        > invaluable in trying to formulate a plan for testing and I appreciate all
        > your collective years of experience.
        >
        > What are your thoughts on "end-to-end" tests? Tests that don't examine the
        > operability of various pieces of a function, but test the entire function as
        > a whole? Our software lead was pretty insistent that we write these kind of
        > tests in addition to unit tests so that the functionality can be placed into
        > an "automated test" framework. The problem is, as I said in my previous
        > post, the prospect of writing an end-to-end test even for something
        > relatively simple such as this "delete" function is rather daunting.
        >
        > Agreed, end-to-end-tests are *much* more work. I have not come to the point
        of writing one yet for the legacy project I'm on, but I've thought a lot on
        how to achieve it.

        However, what I do have is a computer (besides my ordinary work computer)
        that now and then updates a local source tree and tries to compile the whole
        solution. That, at least, gives me a very brief indication on the condition
        of the team's source code.

        I call it "continous integration" but since it lacks any tests running
        (neither unit nor end-to-end) I think it is a little less that CI.

        It's relatively cheap to set such a thing up - I just used command-line
        tools (SVN) and ordinary Visual Studio via command-line (I quite unknown
        feature of the the IDE is that it is runnable window-less for command line
        compilation of .sln files). Put it in a .BAT-file, and made it produce a
        text-file on error, or nothing otherwise. That way I can hava a tray-app on
        my main development computer to monitor the "compilation health" of the
        team's source. I call that mini-application "Build monitor".

        >
        >



        --
        http://olofb.wordpress.com


        [Non-text portions of this message have been removed]
      • Jeff Anderson
        On end to end test take a google at Acceptence Test driven planning and development have your testers or requirements people replace use case details with a
        Message 3 of 11 , Feb 20, 2010
          On end to end test take a google at

          Acceptence Test driven planning and development > have your testers or
          requirements people replace use case details with a combination of
          scenarios and data that can provide unambiguous definitions of done,
          automate to the max extent possible
          ______
          Behavior driven development > structure your tests as

          Given (some state)
          When (some action)
          Then (some result)

          Nice structured format that combines domain driven design and test
          driven development
          ______

          Fitness: wiki that also acts as test runner, store your requirements
          and tests on one online tool

          Cucumber and rspec: BDD framework in ruby supporting natural language
          requirements (or should I say specifications) its in ruby but flavours
          exist for java and .net

          sellenium>OSS web recorder and testing tool, mashups with fitness
          exsist (story test iq)

          Hope that helps
          Jeff

          On 2/18/10, nyrb2 <ua485@...> wrote:
          > Thank you so much for all your responses! As a developer, I find the input
          > invaluable in trying to formulate a plan for testing and I appreciate all
          > your collective years of experience.
          >
          > What are your thoughts on "end-to-end" tests? Tests that don't examine the
          > operability of various pieces of a function, but test the entire function as
          > a whole? Our software lead was pretty insistent that we write these kind of
          > tests in addition to unit tests so that the functionality can be placed into
          > an "automated test" framework. The problem is, as I said in my previous
          > post, the prospect of writing an end-to-end test even for something
          > relatively simple such as this "delete" function is rather daunting.
          >
          >

          --
          Sent from my mobile device

          Jeff Anderson

          http://agileconsulting.blogspot.com/
        • Klaus Hebsgaard
          You should read the book called Growing Object Oriented systems guided by tests - I think it will answer many of your questions... In short do end to end
          Message 4 of 11 , Feb 21, 2010
            You should read the book called "Growing Object Oriented systems guided by
            tests" - I think it will answer many of your questions...

            In short do end to end testing first (formulated them as acceptance tests),
            and then in order for the end to end test to pass, tdd the functionality out
            with unit tests...

            Best regards

            Klaus Hebsgaard

            Website: http://www.hebsgaard.dk
            Blog: http://www.khebbie.dk


            On Fri, Feb 19, 2010 at 12:23 AM, nyrb2 <ua485@...>wrote:

            >
            >
            > Thank you so much for all your responses! As a developer, I find the input
            > invaluable in trying to formulate a plan for testing and I appreciate all
            > your collective years of experience.
            >
            > What are your thoughts on "end-to-end" tests? Tests that don't examine the
            > operability of various pieces of a function, but test the entire function as
            > a whole? Our software lead was pretty insistent that we write these kind of
            > tests in addition to unit tests so that the functionality can be placed into
            > an "automated test" framework. The problem is, as I said in my previous
            > post, the prospect of writing an end-to-end test even for something
            > relatively simple such as this "delete" function is rather daunting.
            >
            >
            >


            [Non-text portions of this message have been removed]
          • nyrb2
            Thanks Klaus -- I bought the book and it s really helping a lot. However, there s one big thing I m struggling with. In order to do the end-to-end
            Message 5 of 11 , Mar 3, 2010
              Thanks Klaus -- I bought the book and it's really helping a lot. However, there's one big thing I'm struggling with. In order to do the end-to-end "acceptance" tests the authors talk about, they employ a Java open-source library called WindowLicker - a framework for the test-driven development of Java systems through the GUI. It does things like finding and controling Swing compenents, synchronizing with Swing's threads and event queues, and wrapping that all up behind a simple API which hooks into the unit testing framework they'd chosen (I think it was JUnit).

              My problem is that I'm working in C++ in Visaul Studio, using a unit test library called cppunit. I've looked but haven't found any equivalent library like WindowLicker, meaning that I am going to have to write all the GUI communication myself. I've been doing that up till now, but it's extremely onerous (using windows calls and handles to find the right controls etc.)

              Do you (or anyone else here) know of any library I can hook into cppunit to do this processing automatically?


              Bryn G.


              --- In extremeprogramming@yahoogroups.com, Klaus Hebsgaard <klaus@...> wrote:
              >
              > You should read the book called "Growing Object Oriented systems guided by
              > tests" - I think it will answer many of your questions...
              >
              > In short do end to end testing first (formulated them as acceptance tests),
              > and then in order for the end to end test to pass, tdd the functionality out
              > with unit tests...
              >
              > Best regards
              >
              > Klaus Hebsgaard
              >
              > Website: http://www.hebsgaard.dk
              > Blog: http://www.khebbie.dk
              >
              >
              > On Fri, Feb 19, 2010 at 12:23 AM, nyrb2 <ua485@...>wrote:
              >
              > >
              > >
              > > Thank you so much for all your responses! As a developer, I find the input
              > > invaluable in trying to formulate a plan for testing and I appreciate all
              > > your collective years of experience.
              > >
              > > What are your thoughts on "end-to-end" tests? Tests that don't examine the
              > > operability of various pieces of a function, but test the entire function as
              > > a whole? Our software lead was pretty insistent that we write these kind of
              > > tests in addition to unit tests so that the functionality can be placed into
              > > an "automated test" framework. The problem is, as I said in my previous
              > > post, the prospect of writing an end-to-end test even for something
              > > relatively simple such as this "delete" function is rather daunting.
              > >
              > >
              > >
              >
              >
              > [Non-text portions of this message have been removed]
              >
            • Kim Gräsman
              Hi Bryn, ... White [1] claims to be able to handle regular Win32 controls. I haven t tried it, so I can t speak for it more than this. It won t plug into
              Message 6 of 11 , Mar 3, 2010
                Hi Bryn,

                On Wed, Mar 3, 2010 at 17:42, nyrb2 <ua485@...> wrote:
                >
                > My problem is that I'm working in C++ in Visaul Studio, using a unit test library called cppunit.  I've looked but haven't found any equivalent library like WindowLicker, meaning that I am going to have to write all the GUI communication myself.  I've been doing that up till now, but it's extremely onerous (using windows calls and handles to find the right controls etc.)
                >
                > Do you (or anyone else here) know of any library I can hook into cppunit to do this processing automatically?

                White [1] claims to be able to handle regular Win32 controls. I
                haven't tried it, so I can't speak for it more than this.

                It won't plug into CppUnit (unless you invest some time and energy
                into C++/CLI for bridging between the two, but I don't think that's
                worth the effort), but you can build a parallel .NET test suite in C#
                or VB, to drive your UI.

                FWIW,
                - Kim

                [1] http://www.codeplex.com/white
              • Donald Murray, P.Eng.
                Hi, ... Maybe the Humble Dialog pattern would allow you to test your Delete function.See the original Michael Feathers paper here:
                Message 7 of 11 , Mar 4, 2010
                  Hi,

                  On Wed, Mar 3, 2010 at 12:04 PM, Kim Gräsman <kim.grasman@...> wrote:

                  > Hi Bryn,
                  >
                  > On Wed, Mar 3, 2010 at 17:42, nyrb2 <ua485@...> wrote:
                  > >
                  > > My problem is that I'm working in C++ in Visaul Studio, using a unit test
                  > library called cppunit. I've looked but haven't found any equivalent
                  > library like WindowLicker, meaning that I am going to have to write all the
                  > GUI communication myself. I've been doing that up till now, but it's
                  > extremely onerous (using windows calls and handles to find the right
                  > controls etc.)
                  > >
                  > > Do you (or anyone else here) know of any library I can hook into cppunit
                  > to do this processing automatically?
                  >
                  > White [1] claims to be able to handle regular Win32 controls. I
                  > haven't tried it, so I can't speak for it more than this.
                  >
                  > It won't plug into CppUnit (unless you invest some time and energy
                  > into C++/CLI for bridging between the two, but I don't think that's
                  > worth the effort), but you can build a parallel .NET test suite in C#
                  > or VB, to drive your UI.
                  >
                  > FWIW,
                  > - Kim
                  >
                  > [1] http://www.codeplex.com/white
                  >
                  >
                  >
                  Maybe the Humble Dialog pattern would allow you to test your Delete
                  function.See the original Michael Feathers paper here:
                  http://www.objectmentor.com/resources/articles/TheHumbleDialogBox.pdf

                  Also, see Gerard Meszaros' site:
                  http://xunitpatterns.com/Humble%20Object.html


                  [Non-text portions of this message have been removed]
                • John Roth
                  There s a stream of thought which says that the best way to test an application through the gui is to not test an application through the gui. Obviously, not
                  Message 8 of 11 , Mar 4, 2010
                    There's a stream of thought which says that the best
                    way to test an application through the gui is to not
                    test an application through the gui.

                    Obviously, not everyone agrees with that, but there are
                    some rather good reasons, mostly revolving around
                    fragility of the tests, a tendency to freeze the gui way too
                    early and a corresponding tendency to make "look and
                    feel" tuning by a real user interface expert way too expensive,
                    why automated testing should stay away from the gui.

                    So how do you do it? The way I've always seen recommended
                    is to split the gui classes into two. The outer class has the
                    interfaces to the gui toolbox for that particular screen, and
                    the absolute minimum of other code needed to make the
                    toolbox work. In particular, there should be no application
                    logic in it at all.

                    The inner class has everything else, including everything that
                    can remotely be described as application logic. It's designed
                    so that the interface with the outer class can be called
                    conveniently from the test scripts.

                    The people who do most of this hang out on the fitnesse
                    mailing list.

                    John Roth

                    nyrb2 wrote:
                    >
                    >
                    > Thanks Klaus -- I bought the book and it's really helping a lot.
                    > However, there's one big thing I'm struggling with. In order to do the
                    > end-to-end "acceptance" tests the authors talk about, they employ a
                    > Java open-source library called WindowLicker - a framework for the
                    > test-driven development of Java systems through the GUI. It does
                    > things like finding and controling Swing compenents, synchronizing
                    > with Swing's threads and event queues, and wrapping that all up behind
                    > a simple API which hooks into the unit testing framework they'd chosen
                    > (I think it was JUnit).
                    >
                    > My problem is that I'm working in C++ in Visaul Studio, using a unit
                    > test library called cppunit. I've looked but haven't found any
                    > equivalent library like WindowLicker, meaning that I am going to have
                    > to write all the GUI communication myself. I've been doing that up
                    > till now, but it's extremely onerous (using windows calls and handles
                    > to find the right controls etc.)
                    >
                    > Do you (or anyone else here) know of any library I can hook into
                    > cppunit to do this processing automatically?
                    >
                    > Bryn G.
                    >
                    > --- In extremeprogramming@yahoogroups.com
                    > <mailto:extremeprogramming%40yahoogroups.com>, Klaus Hebsgaard
                    > <klaus@...> wrote:
                    > >
                    > > You should read the book called "Growing Object Oriented systems
                    > guided by
                    > > tests" - I think it will answer many of your questions...
                    > >
                    > > In short do end to end testing first (formulated them as acceptance
                    > tests),
                    > > and then in order for the end to end test to pass, tdd the
                    > functionality out
                    > > with unit tests...
                    > >
                    > > Best regards
                    > >
                    > > Klaus Hebsgaard
                    > >
                    > > Website: http://www.hebsgaard.dk <http://www.hebsgaard.dk>
                    > > Blog: http://www.khebbie.dk <http://www.khebbie.dk>
                    > >
                    > >
                    > > On Fri, Feb 19, 2010 at 12:23 AM, nyrb2 <ua485@...>wrote:
                    > >
                    > > >
                    > > >
                    > > > Thank you so much for all your responses! As a developer, I find
                    > the input
                    > > > invaluable in trying to formulate a plan for testing and I
                    > appreciate all
                    > > > your collective years of experience.
                    > > >
                    > > > What are your thoughts on "end-to-end" tests? Tests that don't
                    > examine the
                    > > > operability of various pieces of a function, but test the entire
                    > function as
                    > > > a whole? Our software lead was pretty insistent that we write
                    > these kind of
                    > > > tests in addition to unit tests so that the functionality can be
                    > placed into
                    > > > an "automated test" framework. The problem is, as I said in my
                    > previous
                    > > > post, the prospect of writing an end-to-end test even for something
                    > > > relatively simple such as this "delete" function is rather daunting.
                    > > >
                    > > >
                    > > >
                    >
                  • Keith Ray
                    With c++ on ms windows and ui programming, I d try NOT writing any tests against purely ui code. If a ui-only bug shows up that isn t purely cosmetic, consider
                    Message 9 of 11 , Mar 4, 2010
                      With c++ on ms windows and ui programming, I'd try NOT writing any
                      tests against purely ui code. If a ui-only bug shows up that isn't
                      purely cosmetic, consider adding a test for that bit of the ui. I
                      don't see much ROI for unit-testing GUI.

                      If you export your app's functionality via COM, you can drive the
                      application from a scripting language, and you can have app-level
                      tests without ui sensitivity.

                      C. Keith Ray
                      Agile Coaching, training, eLearning
                      http://www.industriallogic.com
                      Sent from my iPhone

                      On Mar 3, 2010, at 8:42 AM, "nyrb2" <ua485@...>
                      wrote:

                      > Thanks Klaus -- I bought the book and it's really helping a lot.
                      > However, there's one big thing I'm struggling with. In order to do
                      > the end-to-end "acceptance" tests the authors talk about, they
                      > employ a Java open-source library called WindowLicker - a framework
                      > for the test-driven development of Java systems through the GUI. It
                      > does things like finding and controling Swing compenents,
                      > synchronizing with Swing's threads and event queues, and wrapping
                      > that all up behind a simple API which hooks into the unit testing
                      > framework they'd chosen (I think it was JUnit).
                      >
                      > My problem is that I'm working in C++ in Visaul Studio, using a unit
                      > test library called cppunit. I've looked but haven't found any
                      > equivalent library like WindowLicker, meaning that I am going to
                      > have to write all the GUI communication myself. I've been doing
                      > that up till now, but it's extremely onerous (using windows calls
                      > and handles to find the right controls etc.)
                      >
                      > Do you (or anyone else here) know of any library I can hook into
                      > cppunit to do this processing automatically?
                      >
                      >
                      > Bryn G.
                      >
                      >
                      > --- In extremeprogramming@yahoogroups.com, Klaus Hebsgaard
                      > <klaus@...> wrote:
                      >>
                      >> You should read the book called "Growing Object Oriented systems
                      >> guided by
                      >> tests" - I think it will answer many of your questions...
                      >>
                      >> In short do end to end testing first (formulated them as acceptance
                      >> tests),
                      >> and then in order for the end to end test to pass, tdd the
                      >> functionality out
                      >> with unit tests...
                      >>
                      >> Best regards
                      >>
                      >> Klaus Hebsgaard
                      >>
                      >> Website: http://www.hebsgaard.dk
                      >> Blog: http://www.khebbie.dk
                      >>
                      >>
                      >> On Fri, Feb 19, 2010 at 12:23 AM, nyrb2 <ua485@...>wrote:
                      >>
                      >>>
                      >>>
                      >>> Thank you so much for all your responses! As a developer, I find
                      >>> the input
                      >>> invaluable in trying to formulate a plan for testing and I
                      >>> appreciate all
                      >>> your collective years of experience.
                      >>>
                      >>> What are your thoughts on "end-to-end" tests? Tests that don't
                      >>> examine the
                      >>> operability of various pieces of a function, but test the entire
                      >>> function as
                      >>> a whole? Our software lead was pretty insistent that we write
                      >>> these kind of
                      >>> tests in addition to unit tests so that the functionality can be
                      >>> placed into
                      >>> an "automated test" framework. The problem is, as I said in my
                      >>> previous
                      >>> post, the prospect of writing an end-to-end test even for something
                      >>> relatively simple such as this "delete" function is rather daunting.
                      >>>
                      >>>
                      >>>
                      >>
                      >>
                      >> [Non-text portions of this message have been removed]
                      >>
                      >
                      >
                      >
                      >
                      > ------------------------------------
                      >
                      > To Post a message, send it to: extremeprogramming@...
                      >
                      > To Unsubscribe, send a blank message to: extremeprogramming-unsubscribe@...
                      >
                      > ad-free courtesy of objectmentor.comYahoo! Groups Links
                      >
                      >
                      >
                    • Keith Ray
                      Also: consider using google test and google mock frameworks for c++, gtest and gmock. Much more power and convience than cppunit. C. Keith Ray Agile Coaching,
                      Message 10 of 11 , Mar 4, 2010
                        Also: consider using google test and google mock frameworks for c++,
                        gtest and gmock. Much more power and convience than cppunit.

                        C. Keith Ray
                        Agile Coaching, training, eLearning
                        http://www.industriallogic.com
                        Sent from my iPhone

                        On Mar 3, 2010, at 8:42 AM, "nyrb2" <ua485@...>
                        wrote:

                        > Thanks Klaus -- I bought the book and it's really helping a lot.
                        > However, there's one big thing I'm struggling with. In order to do
                        > the end-to-end "acceptance" tests the authors talk about, they
                        > employ a Java open-source library called WindowLicker - a framework
                        > for the test-driven development of Java systems through the GUI. It
                        > does things like finding and controling Swing compenents,
                        > synchronizing with Swing's threads and event queues, and wrapping
                        > that all up behind a simple API which hooks into the unit testing
                        > framework they'd chosen (I think it was JUnit).
                        >
                        > My problem is that I'm working in C++ in Visaul Studio, using a unit
                        > test library called cppunit. I've looked but haven't found any
                        > equivalent library like WindowLicker, meaning that I am going to
                        > have to write all the GUI communication myself. I've been doing
                        > that up till now, but it's extremely onerous (using windows calls
                        > and handles to find the right controls etc.)
                        >
                        > Do you (or anyone else here) know of any library I can hook into
                        > cppunit to do this processing automatically?
                        >
                        >
                        > Bryn G.
                        >
                        >
                        > --- In extremeprogramming@yahoogroups.com, Klaus Hebsgaard
                        > <klaus@...> wrote:
                        >>
                        >> You should read the book called "Growing Object Oriented systems
                        >> guided by
                        >> tests" - I think it will answer many of your questions...
                        >>
                        >> In short do end to end testing first (formulated them as acceptance
                        >> tests),
                        >> and then in order for the end to end test to pass, tdd the
                        >> functionality out
                        >> with unit tests...
                        >>
                        >> Best regards
                        >>
                        >> Klaus Hebsgaard
                        >>
                        >> Website: http://www.hebsgaard.dk
                        >> Blog: http://www.khebbie.dk
                        >>
                        >>
                        >> On Fri, Feb 19, 2010 at 12:23 AM, nyrb2 <ua485@...>wrote:
                        >>
                        >>>
                        >>>
                        >>> Thank you so much for all your responses! As a developer, I find
                        >>> the input
                        >>> invaluable in trying to formulate a plan for testing and I
                        >>> appreciate all
                        >>> your collective years of experience.
                        >>>
                        >>> What are your thoughts on "end-to-end" tests? Tests that don't
                        >>> examine the
                        >>> operability of various pieces of a function, but test the entire
                        >>> function as
                        >>> a whole? Our software lead was pretty insistent that we write
                        >>> these kind of
                        >>> tests in addition to unit tests so that the functionality can be
                        >>> placed into
                        >>> an "automated test" framework. The problem is, as I said in my
                        >>> previous
                        >>> post, the prospect of writing an end-to-end test even for something
                        >>> relatively simple such as this "delete" function is rather daunting.
                        >>>
                        >>>
                        >>>
                        >>
                        >>
                        >> [Non-text portions of this message have been removed]
                        >>
                        >
                        >
                        >
                        >
                        > ------------------------------------
                        >
                        > To Post a message, send it to: extremeprogramming@...
                        >
                        > To Unsubscribe, send a blank message to: extremeprogramming-unsubscribe@...
                        >
                        > ad-free courtesy of objectmentor.comYahoo! Groups Links
                        >
                        >
                        >
                      • Charlie Poole
                        +1 on all except the COM part... 1. Test directly below the UI, but... 2. make the UI incredibly thin The Visual Studio IDE is your enemy here. Every time you
                        Message 11 of 11 , Mar 5, 2010
                          +1 on all except the COM part...

                          1. Test directly below the UI, but...
                          2. make the UI incredibly thin

                          The Visual Studio IDE is your enemy here. Every time you click to
                          create an event handler the IDE opens up a spot for you to add
                          more code to the UI itself. Resist that temptation and call into
                          your separate assembly that handles business logic.

                          Simply doing this can take you a long way. At some point, you
                          should look into using MVC or MVP rather than just MV.

                          COM, in my view, should be reserved for interacting with legacy
                          code that already uses it. Live is complicated enough already. :-)

                          Charlie

                          > -----Original Message-----
                          > From: extremeprogramming@yahoogroups.com
                          > [mailto:extremeprogramming@yahoogroups.com] On Behalf Of Keith Ray
                          > Sent: Thursday, March 04, 2010 6:12 PM
                          > To: extremeprogramming@yahoogroups.com
                          > Cc: extremeprogramming@yahoogroups.com
                          > Subject: Re: [XP] Re: More on Unit Testing
                          >
                          > With c++ on ms windows and ui programming, I'd try NOT
                          > writing any tests against purely ui code. If a ui-only bug
                          > shows up that isn't purely cosmetic, consider adding a test
                          > for that bit of the ui. I don't see much ROI for unit-testing GUI.
                          >
                          > If you export your app's functionality via COM, you can drive
                          > the application from a scripting language, and you can have
                          > app-level tests without ui sensitivity.
                          >
                          > C. Keith Ray
                          > Agile Coaching, training, eLearning
                          > http://www.industriallogic.com
                          > Sent from my iPhone
                          >
                          > On Mar 3, 2010, at 8:42 AM, "nyrb2" <ua485@...>
                          > wrote:
                          >
                          > > Thanks Klaus -- I bought the book and it's really helping a lot.
                          > > However, there's one big thing I'm struggling with. In order to do
                          > > the end-to-end "acceptance" tests the authors talk about,
                          > they employ
                          > > a Java open-source library called WindowLicker - a
                          > framework for the
                          > > test-driven development of Java systems through the GUI. It does
                          > > things like finding and controling Swing compenents, synchronizing
                          > > with Swing's threads and event queues, and wrapping that
                          > all up behind
                          > > a simple API which hooks into the unit testing framework
                          > they'd chosen
                          > > (I think it was JUnit).
                          > >
                          > > My problem is that I'm working in C++ in Visaul Studio,
                          > using a unit
                          > > test library called cppunit. I've looked but haven't found any
                          > > equivalent library like WindowLicker, meaning that I am
                          > going to have
                          > > to write all the GUI communication myself. I've been doing that up
                          > > till now, but it's extremely onerous (using windows calls
                          > and handles
                          > > to find the right controls etc.)
                          > >
                          > > Do you (or anyone else here) know of any library I can hook into
                          > > cppunit to do this processing automatically?
                          > >
                          > >
                          > > Bryn G.
                          > >
                          > >
                          > > --- In extremeprogramming@yahoogroups.com, Klaus Hebsgaard
                          > <klaus@...>
                          > > wrote:
                          > >>
                          > >> You should read the book called "Growing Object Oriented systems
                          > >> guided by tests" - I think it will answer many of your questions...
                          > >>
                          > >> In short do end to end testing first (formulated them as
                          > acceptance
                          > >> tests), and then in order for the end to end test to pass, tdd the
                          > >> functionality out with unit tests...
                          > >>
                          > >> Best regards
                          > >>
                          > >> Klaus Hebsgaard
                          > >>
                          > >> Website: http://www.hebsgaard.dk
                          > >> Blog: http://www.khebbie.dk
                          > >>
                          > >>
                          > >> On Fri, Feb 19, 2010 at 12:23 AM, nyrb2 <ua485@...>wrote:
                          > >>
                          > >>>
                          > >>>
                          > >>> Thank you so much for all your responses! As a developer,
                          > I find the
                          > >>> input invaluable in trying to formulate a plan for testing and I
                          > >>> appreciate all your collective years of experience.
                          > >>>
                          > >>> What are your thoughts on "end-to-end" tests? Tests that don't
                          > >>> examine the operability of various pieces of a function, but test
                          > >>> the entire function as a whole? Our software lead was pretty
                          > >>> insistent that we write these kind of tests in addition to unit
                          > >>> tests so that the functionality can be placed into an "automated
                          > >>> test" framework. The problem is, as I said in my previous
                          > post, the
                          > >>> prospect of writing an end-to-end test even for something
                          > relatively
                          > >>> simple such as this "delete" function is rather daunting.
                          > >>>
                          > >>>
                          > >>>
                          > >>
                          > >>
                          > >> [Non-text portions of this message have been removed]
                          > >>
                          > >
                          > >
                          > >
                          > >
                          > > ------------------------------------
                          > >
                          > > To Post a message, send it to: extremeprogramming@...
                          > >
                          > > To Unsubscribe, send a blank message to:
                          > > extremeprogramming-unsubscribe@...
                          > >
                          > > ad-free courtesy of objectmentor.comYahoo! Groups Links
                          > >
                          > >
                          > >
                          >
                          >
                          > ------------------------------------
                          >
                          > To Post a message, send it to: extremeprogramming@...
                          >
                          > To Unsubscribe, send a blank message to:
                          > extremeprogramming-unsubscribe@...
                          >
                          > ad-free courtesy of objectmentor.comYahoo! Groups Links
                          >
                          >
                          >
                          >
                        Your message has been successfully submitted and would be delivered to recipients shortly.