Merken

Writing a Test Framework from Scratch

Zitierlink des Filmsegments
Embed Code

Automatisierte Medienanalyse

Beta
Erkannte Entitäten
Sprachtranskript
no and that the and the I the thank you everyone for lasting so long you know it's been a on the tax and a wine Davis and not elsewhere as is spider we talking label making a test framework from scratch and a founding member of
this year we're again it's the 1st and oldest re-radiate back we came up with brigade of the world are now and installed
Seattle and available the mostly
offered many tests now which happens to be according to the route to what's on the most popular CCAs framework I really and I only mention that part because I'm kind of a standard that I'm dating and so setting
expectations and then I was at the beginning my talk so this is a very could have a talk on the go into detail about the what's the hows and the whys of writing a test framework I've got a few slides are coming up to 9 . 4 slides a minute I if I ignore the 30 minutes and so stock and to 35 so that the Knight 4 slides minutes you talk twice over here is art and recorded and published the water there into I I did we find that adding more slides adds more explanation in comprehension and you makes atop a smoother as long as you have the the problem so the presentations and published the slides throughout the about of it and there's a facsimile of the code that I'll be presenting that is active at you as well 1st a famous quote not set of
items person tell me and I forget
teach me and I may remember involve me and I'll who actually so this is a mystery but it's usually attributed to Mr. Frank whether to legitimate
cool or not at the point of unimportant common cold walking talks don't get me
wrong now could those are bad summer actually quite good but and they're absolutely necessary for work and we talking about the what we talks quite simply so I
could write this talk in my sleep by simply working
through the complementation many tasks in explaining each and every line he learned nothing from that
so the you learn almost nothing from it forgetting it almost as quickly as you so the many problems occur what
users the boring the top down as a
result we focus on the what's and not the
wise they're all good reasons to tune out and not learn a thing so these are all good reasons for me not to do could walk through many test that call before that wasn't by
Benjamin Franklin the real quote it's based on is much better not having heard something is not as good as having for it the having heard it is not as good as having seen it having seen is not as good as knowing that knowing it is not as good as putting and practice I'm not going to try to murder that
the here's a more concise versions for those who think there that was too many words the and here's a
version for tender love who is my most verity of
friends so starting from
scratch that's the point of this talk
working up from nothing is the closest
that I can gets to allowing you to join me in building up a test framework from
scratch I will try to describe this in a way that
you can literally caught up at the same time that I described it and understand the steps that you went through to
get there now would be a good time to open up your laptops if you attempt this many have tried you
have succeeded further this will not be many test by the end of the talk obviously is that is that we
some subset and I'll applied 80 20 rule to show the most of what many test can do in a known to emphasize that I'll be referring to this is
my protest from here on out and always to be political level and finally I encourage you to
deviate from the path and experiments to
do things differently and you might wind up understanding that the choices that I made finally
the stock is an adaptation of a chapter of a book that I'm writing on many tests are more fruit will be on that at the end of a talk so where to
began at the bottom of the atomic unit of any test for America the assertions so let's start with planar
listed In the simplest form a search is
incredibly straightforward it only takes 1 thing the result of an expression that fails if that isn't true the and that's it the give everything you need a test thank
you please my my but when it comes out of the any questions the now I would like to have a
few more bells muscles than that of the before and those let's figure out what I wrote already and wine In this case I chose
quite arbitrarily to raise an exception of the value of the test is interesting I
could have chosen to do something other than raising exceptions like throwing or pushing some
sort of failure and since the collection of failures and returning the user trade offs so
I'm and enough to all these choices it doesn't really matter as long as you want reporting the filled assertion at some point I mostly chose to raise an
exception because exceptions work well for my brain there's an added benefit in that interrupts the
execution of the tests it jumps out of the current level of the code more this later so if you ran this expression
1 double equals 1 would evaluated true which again sent to the test are to assert and that would do nothing in response it the past however if you run this expression 1 double equals to evaluate to false that would give sense to the test I assert and that when appraising exception the at some point
there will be mechanisms to deal with those exceptions in Greece we move on before now the whole test we will grind to a halt on the 1st field test
1 problem we currently have that the Rays excite an exception report to the place the race was called inside the assert and not worthy assertion was called I want to only talk about the place for the assertion failed online 5 a test of our being so a cleaner with a clear exception a bit by change the way the race is called raise allows you to specify what exception class to use the backtrace you'd like to show I didn't know that until about 4 weeks ago police color for the backtrace which returns the current runtime stack where color is called now we see where the test actually felt that much more useful to develop a dealing with the Philly 2nd we a 2nd
exception the assertion survey assertEquals now the final answer I can
use that develop any assertion that anyone possibly need
about 90 per cent of all the test that I write use assert equal luckily it's
incredibly simple to implement I just pass resulted day a double equals B to a certain assert does the rest of the work the news ideas that were 2 plus 2 does equal for it would pass it would pass to research in order 2 plus 2 dozen equals 5 it would pass to assert there are certain O K this is really all I
need to do most of my work quite happily but the way that it stands right now it has a pretty unhelpful error message would have filled assertion raises 1st the backtrace is pointing
at a certain equals I just fix this
mostly I'm using color for the batteries and included the entire call stack including the other assertions that may be up the stack so I need to filter those assertions from
slits fix that by deleting everything at the start of the backtrace that isn't in the implementation file itself this is still
ugly the failure just says field tests so let's make it possible for certain equal to supply more information let's pull up the
error message into an optional argument and use that argument and race then we
change 30 equal to use that with a helpful message the now we get error messages look like this that's much more
useful although it may not still be on % resilient but it'll do for now let's add 1
more assertions the certain delta 1 people 1
mistake people make time and again as misunderstanding have computers do floats the rule is
really really simple
never ever ever test floods for a quality yes there are
exceptions to this rule but if you stick to that rule you'll be fine when time so well we have a equal we should not be using for floats we're going to write a certain delta
instead that's just for comparing floats
what they should do is the if the difference between 2 numbers is close enough
where close enough our version at least is simply going to be within 1 1 thousandth you make a fancy later before now
done is more important than good so this is
what it looks like almost the exact same answered equal except using the formula stated previously the and this is how it's used yeah
and works where the gate so we're than me that
means for now assert solid enough for a general-purpose use then we can write other
assertions writing other assertions is finding
the necessary even but I did take hours and I'm only 25 % through my slides I will consider this
as an exercise for you after the conference but think now about what
your favorite thing the testers how would
you write an assertion for you should do that then
have a cookie so once you 1 test the 1
right many tests this 1st to introduce problems on its own the being nice to build keep them
separate there are many reasons why you'd want to break a protest
and keep them separate organization
refactoring reuse safety
priortization parallelization
it would be nice to keep them separate but how do you do that we do something really quickly and easily
like this will call the test method it'll take some string describing the test itself will take a block of code with assertions in and it's equally easily it's easy to implement you ignore the arguments can yield to this gives us the benefit the the name the
test and you can put them in blocks of the agency of the
separate black the aliki and leaky
tests in fact results now we write
can write multiple tests and give them organize we need to be able to trust them the problem is
that these tests are actually all that separate from each other you here we can see that a equals 1 of the top 1st asserts that it is 1 and passes the 2nd test mutates that local variable and tests that passes in the 3rd test which expects to be you like the for the 1st test fails because it has been mutated what
we really want is for those tests to be completely independent of each other the fact that
1 test committed a local variable that is used by another test is simply a mistake this goes against
good testing practices which state that
the test should always pass regardless of what was run what order they were run in or anything else otherwise
you don't trust the tests and trust in the test is crucial were this using methods the the
number ways that we could turn a patches of the
simplest perhaps it is just not to do it in the 1st place instead of just use Ruby
provides a mechanism for supporting blocks of code making them immune outer scopes it's called the method and it's free the nicest thing about
this approach is that it's absolutely free there's no
cost using this that you are already paying by using Ruby in the 1st place it's also hard remember that by
using plain Ruby is that anyone can understand it the it does have some drawbacks the
1st you have to run the methods yourself that's fine for now will address later yeah another
perhaps more pressing issues of this code duplication in the previous examples there are
simple ways to get around this to you I'm not going bother with that going that at this time if you stick to
plane Ruby it should be pretty easy to do that so the selected exercise for you again now the
remote has separate by methods how do we get them to run same run any method you call them we
could come up with a more complicated way and we will but this different methods are good means to
separate tests the more problems arise unique method names is harder organize reuse compose etc. luckily re becomes of another mechanism to solve classes it the yeah did I just say to keep them separate
tho the idea it would be nice to organize and there's some balance in between so how we do that
well we take the previous code can we wrapped in the class done but how us
wrapping the medicine class breaks the current runs In
order to fix that we need an instance of each class before we call the method so we add that to each
line were passing again and granted this
doesn't really do anything for us it
does group the testing classes but more
importantly puts us an ideal position To make a
test run themselves right now we manually
instantiate call method for each test
let's push our responsibility towards the instance they have run its own test
by adding a run instance method that takes a name and invokes it was sent sent this doesn't look
like much either In fact by adding the called
run we made it more cumbersome but this will
make the next steps to breezy it also provides us
with a location or can extend what running a test even means for example the run
method would be a good place to add setup and teardown features or anything else you may wanna do would you
add running 1st manually still pretty cumbersome slots
address that next now an instance knows how to
run itself but to make the class know how to run all of its instances we can use
public instance methods and filter out all methods that and an underscore test methods
returns an array of all the public instance methods on a class or module then we can use innumerable scrap method to filter on notes In
wrapped up in a class method that instantiates and runs each test this really doesn't do anything different other doing before just enumerate over the methods this allows us
to collapse this in this the this would be
a good point to pause and applies to refactor 1
is well and good but it's only on 1 test class in order really benefit from this we should
push up to a common ancestor let's make a parent
class the factor that we simply reorganize the methods in
a new class of rain to call it tests because a very creative note that we also scooped up all the assertions while we're at
now we make all over test classes subclasses of that class and that's all
there is to it do that all test classes now benefit from could readers this makes a super
trivial to have a bunch of classes of test that can run themselves so what's push that further then only left addresses were remain we
tell each class to run its tests so it's
on that too since were using subclasses to
organize our tests we can use an underappreciated feature of Ruby the
class inherited book every time a new
test subclasses created it'll
be automatically recorded and tensile
notifier all of them off when we tell it to 1st
we need some place to record the things we need to run the then we use the inherited hope to record all the classes the subclass test a From there it is trivial to enumerate the collection tell each 1 to run this test that
allows us to rewrite this to this now the ideal to put in its own file sleep is requiring and take everything off and that's all there is
to it so my good as it can and should
at this point Iran's tests class that's great
but but now noise testing is supported the nice know what actually happened on the 1 hand
silence is golden you don't see an exception than everything worked right the adding
visible the situations with Russian proverb trust but verify is a good policy that so let's
give the framework wave reporting the results and see if we can enhance things while render How do we
know what the results of a run I personally would be
pretty happy just seeing that something ran let's start with that as a minimal goal let's put
dot for every test as a side note this is quite possibly my favorite slide ever made you that that it's a tough to be so probably something about ink density
so like that a prince and outputs and we're done this is stupid simple thing to do the emphasis perhaps is on stupid quite simply we 2
. for every test and then we add a new line to make it so keep a pretty at the end of the run so doing so we'd see this another we see
that we ran 3 tests in that they all past
that's actually really good information and now I'm much happier but what about failures what
happens when a test fails currently the test fails Amélie quick since raising an unhandled exception that's not chou
terrible but it does imply that you only see the 1st problem the races and that might not be the problem the you actually do it that might not provide as
much insight pattern matching ability that humans have 5 seeing all the Phillies once souls clean this up will rescue exceptions and print out what
happens you had wrapped up in began with the rescue and capture the variable the printouts the message and we print out the first one the vectors now we see all the test for
girls of failures we also he was a backtrace is really for in the 1st line of this of the of the vectors perhaps is not the prettiest
output but it is much better than before
but there are several things that all like about the scope
model runtime time Commissioner OK and despite the speakers I don't like the logic for running a test and doing I O is mixed up in the same method it's just masses so all address that In the process refactor the code to be more maintainable incapable the the problem I
have is that the run a class method is doing way more than just running here we can see that it is about 4 categories of things that it's doing the 1st thing I wanna do is separated exception
handling from the test you really don't like that test
class run is handling both pretty an exception handling but I especially don't like the
exception handling slots address that 1st since
test class 1 calls test instance Ron which calls direction tests it's 2 pops up from or any actual exceptions are getting rid we Sheri
factor this and break up the responsibilities I
want run all tests to only deal with running test classes from the top and when each class to
run the individual tests and 1
each test instance to run a single test and handle any failures but I want
something else entirely to do a showing the test results slots move forward with that more 1st push the rescue down 1
level so that test instance run returns the raised exception were false if there was no failure now we change test class 1
to print appropriately based on the return value
now have exceptionally pushed down the the thing that's actually the tests having exceptions
only raise a single level usually means you're in a better place to deal with them but doing this we've also converted some exception handling into a simple conditional on next let's look at the I
O let's extract the conditional response
responsible for I O into its own method and will call that report by doing this we put
ourselves into a better position to move that out entirely
so let's do exactly the we extract the report
method into its own class called report regret that puts 2 already input that a method called Don this lets us re write
run all tests into something that is much cleaner we instantiate a reporter objects we pass it through we call them at the end I think it is jumped myself I didn't over myself we greater for instance tests we use that throughout we passed down there for instance to run we use that to call report instead In the his name was a block variable before we need past that underreported . report as well
doing this removed all I O from the test class and delegated elsewhere throughout these
changes you should be marry running the test to ensure that it works the same but in this last
case it doesn't the class name is wrong we push reporting into a separate class for now
political quick-fix row by passing in the class i'm intentionally focusing on
fixing this bug not using the right abstraction sometimes sometimes the right thing to do but you pay a price in doing so so that new
arguments to the report method the largest killer k right pass in the current class which is
self in any class method to report this
fixes output back to what we expect to see
but we had at a 3rd argument to do it and actually
had that were doing things wrong so let's try
to address this now we don't need to pass the actual
exception report we invest anything that has all
of the information in the report means to test at to reports the test result is and what better
thing than the test itself all we need to
do is to make the test record any failure that has that I'm I have and make that accessible to the reporter let's add a failure
attributed test and defaulted to false then we modify we modify test run to record the exception and failure the return the test instance instead of the exception now we can use the access a
reporter to get the message and the backtrace let's clean up the mess you made 3rd
argument now that he is a test instance ribald your the
decay argument the this gives us back to 2
arguments which in my opinion is still 1 to many so let's try to remove names With a little
tweaking to instances can know the name of the class of the tests that are on 1st by adding an accessor and then storing it initialize then bypass the name initializer
and not to run the and finally by removing the argument from run and using the axis instead of just shifted things forward this means that
a test instances storing everything the reporter needs to do its job and we can get rid of the name argument 1 more thing that I do not like is
mixed types we don't need them right now use
either false or the instance of a failed test but tests no know whether they
passed a not and helping namely the source of
pesky bugs so let's give it a false by
adding an ensure block with an explicit returns amended always make sure they pointed out how we knew where the false make sure that the run method always returns self next let's add an alias for the Canadian accessor failure a and switch reported uses new predicate method to test this looks pretty good now I just don't
like the name he anymore so there is no longer an exception but a test instance solitary name let's call result this makes the
code much more descriptive albeit a bit longer OK at this point I could call it a
nite but the output is still a bit crafty I want to
enhance the output there be nicer if
we separated the run overview meaning the dots in any failure indicators from the failure details something like this so
let's change report to store off the failure and prints all of them in Don this is a pretty easy to do we need a new failures array to store them we
make an accessor initializes then we need to print and
half in the case of a failure in store off the result in the case the value finally we need to
move the printing go down into an enumeration on that are red now the output looks
much much better the but were not
quite done because I have 5 minutes left at there's
just a couple things laughter are getting on my nerves we change both report done
quite a bit they're no longer doing what they say they
do so let's rename them report become shovel and done becomes summary we will
use those names and test this point I'm
actually pretty happy code but we're not done yet
I'd like gets more enhancements 1 common
problem that people often have writing tests is that the test went up depending on side effects of a previous test for the past in this case at if if
that test is run by itself on a different words going to fail this goes against the previous will testing that
test should pass regardless of the order and easy
enforce this is to run the tests in a random order
that's easy to do an occurrence of but I rather namics too many things back in this method so let's start by
extracting the code that generates all attest to run now test I run only deals with enumerating the test names and fire them off sort a better place to randomize the test we just do that we shuffle but most working the that's really all there
is to it we could give francium push up to run all
tests and randomize across the classes in the methods and get all fancy and stuff but again
this is a good compromise only that as an exercise for you so we're done for now where rewind up
with well we wanna with about 70 lines really
the that is a good portion on many has actually does it well factors as your
duplications of any kind the complexity score is
incredibly low floods at about 70 which is
about 5 For method which is about half of the industry average onset of rest he with any
comments the code is incredibly readable the
reporter 1st column of the test class methods 2nd column in the test instance methods all fit on 1 slide that's not
bad that she runs about twice as fast beneath us because those less the worst thing about this
talk is there's been about nine slides per 2 lines of code but that's a price that I'm willing to pay in order to make this is explainable as possible so how do
we get there we start with the atom we built that up to
molecules we gathered tests and
methods and methods in the classes we
taught the class had run 1 method we taught the class
had run all of its methods we taught it how
to run all classes then the
body without in reporting error handling and
randomization is a cherry on top of within the
patches as book again the as so I'm hoping
soon published a small book and Michael hurdles learn enough series well enough for a lot of to be dangerous I but if that is well
I'm going to be doing a complete book on many test and perhaps testing the loss of the I don't know I I'll have a sample
chapter coming out soon for a view
that is not ready yet so please follow me on Twitter for announcements thank you and please it
thank if I might this my was my wall
Dämpfung
Framework <Informatik>
Statistischer Test
Spider <Programm>
Signifikanztest
Framework <Informatik>
Computeranimation
Signifikanztest
EDV-Beratung
Framework <Informatik>
Einheit <Mathematik>
Mereologie
Routing
Signifikanztest
Framework <Informatik>
Computeranimation
Standardabweichung
Eindringerkennung
Wasserdampftafel
Kombinatorische Gruppentheorie
Code
Framework <Informatik>
Signifikanztest
Computeranimation
Rechenschieber
Erwartungswert
Framework <Informatik>
Statistischer Test
Code
Fokalpunkt
Rechenschieber
Punkt
Framework <Informatik>
Code
Signifikanztest
Computeranimation
Resultante
Task
Komplementarität
Framework <Informatik>
Signifikanztest
Gerade
Computeranimation
Framework <Informatik>
Reelle Zahl
Statistischer Test
Interprozesskommunikation
Signifikanztest
Computeranimation
Punkt
Dämpfung
Framework <Informatik>
Statistischer Test
Versionsverwaltung
Gebäude <Mathematik>
Wort <Informatik>
Signifikanztest
Framework <Informatik>
Computeranimation
Teilmenge
Framework <Informatik>
Statistischer Test
Code
Notebook-Computer
Schlussregel
Signifikanztest
Computeranimation
Signifikanztest
Framework <Informatik>
Anpassung <Mathematik>
Signifikanztest
Auswahlaxiom
Computeranimation
Übergang
Resultante
Arithmetischer Ausdruck
Bildschirmmaske
Einheit <Mathematik>
Framework <Informatik>
Statistischer Test
Minimum
Signifikanztest
Ebener Graph
Computeranimation
Ausnahmebehandlung
Framework <Informatik>
Statistischer Test
Ausnahmebehandlung
Signifikanztest
Quick-Sort
Computeranimation
Signifikanztest
Arithmetischer Ausdruck
Punkt
Framework <Informatik>
Ausnahmebehandlung
Signifikanztest
Code
Auswahlaxiom
Computeranimation
Übergang
Kraftfahrzeugmechatroniker
Arithmetischer Ausdruck
Punkt
Framework <Informatik>
Statistischer Test
Endogene Variable
PASS <Programm>
Ausnahmebehandlung
Signifikanztest
Computeranimation
Fehlermeldung
Bit
Rechenzeit
Klasse <Mathematik>
Mathematisierung
Rechenzeit
Ausnahmebehandlung
Sondierung
Signifikanztest
Systemaufruf
Computeranimation
Framework <Informatik>
Statistischer Test
Kantenfärbung
Verkehrsinformation
Framework <Informatik>
Statistischer Test
Ordnung <Mathematik>
Signifikanztest
Computeranimation
Framework <Informatik>
Systemaufruf
Kantenfärbung
Signifikanztest
Computeranimation
Fehlermeldung
Parametersystem
Fehlermeldung
Framework <Informatik>
Rechenzeit
Mathematisierung
Implementierung
Information
Elektronische Publikation
Signifikanztest
Message-Passing
Computeranimation
Fehlermeldung
DoS-Attacke
Algorithmische Zahlentheorie
Framework <Informatik>
Statistischer Test
Schlussregel
Signifikanztest
Computeranimation
Subtraktion
Framework <Informatik>
Versionsverwaltung
Zahlenbereich
Ausnahmebehandlung
Schlussregel
Signifikanztest
Computeranimation
Arithmetisches Mittel
Verknüpfungsglied
Framework <Informatik>
Stereometrie
Signifikanztest
Computeranimation
Ausdruck <Logik>
Signifikanztest
Rechenschieber
Framework <Informatik>
Signifikanztest
Computeranimation
Signifikanztest
Framework <Informatik>
Parallelrechner
Selbst organisierendes System
Statistischer Test
Refactoring
Cookie <Internet>
Elektronischer Datenaustausch
Parallele Schnittstelle
Signifikanztest
Computeranimation
Parametersystem
Framework <Informatik>
Statistischer Test
p-Block
Signifikanztest
Code
Computeranimation
Zeichenkette
Resultante
Signifikanztest
Framework <Informatik>
Statistischer Test
PASS <Programm>
p-Block
p-Block
Signifikanztest
Computeranimation
Signifikanztest
Framework <Informatik>
Algebraisch abgeschlossener Körper
Statistischer Test
Güte der Anpassung
Ordnung <Mathematik>
Stochastische Abhängigkeit
Signifikanztest
Computeranimation
Schlussregel
Signifikanztest
Kraftfahrzeugmechatroniker
Patch <Software>
Freeware
Framework <Informatik>
Statistischer Test
PASS <Programm>
Zahlenbereich
p-Block
Signifikanztest
Code
Computeranimation
Framework <Informatik>
Code
Signifikanztest
Code
Computeranimation
Signifikanztest
Arithmetisches Mittel
Ebene
Kraftfahrzeugmechatroniker
Framework <Informatik>
Selbst organisierendes System
Klasse <Mathematik>
Eindeutigkeit
Objektklasse
Signifikanztest
Computeranimation
Framework <Informatik>
Klasse <Mathematik>
PASS <Programm>
Ordnung <Mathematik>
Signifikanztest
Code
Computeranimation
Instantiierung
Signifikanztest
Ortsoperator
Klasse <Mathematik>
Gruppenkeim
Systemaufruf
Signifikanztest
Computeranimation
Framework <Informatik>
Gruppenkeim
Statistischer Test
Endogene Variable
Ideal <Mathematik>
Gerade
Instantiierung
Ortsoperator
Framework <Informatik>
Statistischer Test
URL
Signifikanztest
Computeranimation
Instantiierung
Framework <Informatik>
Statistischer Test
Klasse <Mathematik>
Digitalfilter
Objektklasse
Signifikanztest
Computeranimation
Instantiierung
Subtraktion
Punkt
Framework <Informatik>
Statistischer Test
Refactoring
Klasse <Mathematik>
Objektklasse
Ordnung <Mathematik>
Ranking
Signifikanztest
Computeranimation
Framework <Informatik>
Statistischer Test
Vererbungshierarchie
Klasse <Mathematik>
Vererbungshierarchie
Signifikanztest
Teilbarkeit
Computeranimation
Signifikanztest
Framework <Informatik>
Statistischer Test
Klasse <Mathematik>
Adressraum
Vererbungshierarchie
Objektklasse
Signifikanztest
Computeranimation
Datensatz
Framework <Informatik>
Statistischer Test
Klasse <Mathematik>
Vererbungshierarchie
Signifikanztest
Computeranimation
Signifikanztest
Punkt
Framework <Informatik>
Klasse <Mathematik>
Geräusch
Ideal <Mathematik>
Elektronische Publikation
Ranking
Signifikanztest
Computeranimation
Resultante
Framework <Informatik>
Wellenlehre
Volumenvisualisierung
Ausnahmebehandlung
Signifikanztest
Framework <Informatik>
Computeranimation
Rechenschieber
Framework <Informatik>
Statistischer Test
Signifikanztest
Computeranimation
Dichte <Physik>
Framework <Informatik>
Statistischer Test
PRINCE2
Signifikanztest
Gerade
Computeranimation
Funktion <Mathematik>
Framework <Informatik>
Statistischer Test
Mustersprache
Hochdruck
Ausnahmebehandlung
Information
Signifikanztest
Computeranimation
Message-Passing
Framework <Informatik>
Backtracking
Vektorraum
Signifikanztest
Gerade
Message-Passing
Computeranimation
Funktion <Mathematik>
Informationsmodellierung
Prozess <Physik>
Framework <Informatik>
Statistischer Test
Refactoring
Adressraum
Rechenzeit
Ruhmasse
Mathematische Logik
Signifikanztest
Code
Computeranimation
Message-Passing
Ausnahmebehandlung
Framework <Informatik>
Statistischer Test
Kategorie <Mathematik>
Backtracking
Klasse <Mathematik>
Ausnahmebehandlung
Instantiierung
Signifikanztest
Computeranimation
Signifikanztest
Kontrollstruktur
Klasse <Mathematik>
Ausnahmebehandlung
Objektklasse
Teilbarkeit
Signifikanztest
Computeranimation
Richtung
Framework <Informatik>
Statistischer Test
Endogene Variable
Instantiierung
Signifikanztest
Resultante
Message-Passing
Ausnahmebehandlung
Framework <Informatik>
Statistischer Test
Klasse <Mathematik>
Ausnahmebehandlung
Signifikanztest
Computeranimation
Instantiierung
Übergang
Ortsoperator
Signifikanztest
Message-Passing
Framework <Informatik>
Backtracking
Endogene Variable
Ausnahmebehandlung
Signifikanztest
Verkehrsinformation
Computeranimation
Signifikanztest
Klasse <Mathematik>
Ein-Ausgabe
Objektklasse
Signifikanztest
Computeranimation
Objekt <Kategorie>
Repository <Informatik>
Variable
Message-Passing
Framework <Informatik>
Backtracking
Große Vereinheitlichung
Verkehrsinformation
Instantiierung
Datensatz
Framework <Informatik>
Statistischer Test
Abstraktionsebene
Mathematisierung
Klasse <Mathematik>
Signifikanztest
Computeranimation
Programmfehler
Parametersystem
Message-Passing
Framework <Informatik>
Rechter Winkel
Backtracking
Klasse <Mathematik>
Signifikanztest
Verkehrsinformation
Message-Passing
Computeranimation
Funktion <Mathematik>
Resultante
Objekt <Kategorie>
Ausnahmebehandlung
Ausnahmebehandlung
Signifikanztest
Computeranimation
Datensatz
Datensatz
Framework <Informatik>
Statistischer Test
Information
Verkehrsinformation
Instantiierung
Signifikanztest
Parametersystem
Klasse <Mathematik>
Objektklasse
Signifikanztest
Computeranimation
Message-Passing
Framework <Informatik>
Statistischer Test
Backtracking
Verkehrsinformation
Message-Passing
Chi-Quadrat-Verteilung
Instantiierung
Parametersystem
Kartesische Koordinaten
Abstraktionsebene
Instantiierung
Objektklasse
Signifikanztest
Computeranimation
Message-Passing
Framework <Informatik>
Prozess <Informatik>
Statistischer Test
Datentyp
Backtracking
Verkehrsinformation
Instantiierung
Signifikanztest
Prädikat <Logik>
Aliasing
Framework <Informatik>
Statistischer Test
p-Block
Aliasing
Signifikanztest
Computeranimation
Programmfehler
Instantiierung
Resultante
Bit
Punkt
Ausnahmebehandlung
Code
Signifikanztest
Computeranimation
Message-Passing
Isolation <Informatik>
Skalarprodukt
Framework <Informatik>
Statistischer Test
Backtracking
Indexberechnung
Instantiierung
Funktion <Mathematik>
Resultante
Message-Passing
Framework <Informatik>
Abzählen
Backtracking
Hochdruck
Speicher <Informatik>
Signifikanztest
Verkehrsinformation
Computeranimation
Funktion <Mathematik>
Message-Passing
Bit
Framework <Informatik>
Backtracking
Signifikanztest
Verkehrsinformation
Computeranimation
Randomisierung
Soundverarbeitung
Signifikanztest
Repository <Informatik>
Punkt
Framework <Informatik>
Statistischer Test
Wort <Informatik>
Signifikanztest
Computeranimation
Signifikanztest
Zufallszahlen
Framework <Informatik>
Statistischer Test
Ordnung <Mathematik>
Ordnung <Mathematik>
Signifikanztest
Code
Quick-Sort
Computeranimation
Schlussregel
Framework <Informatik>
Klasse <Mathematik>
Randomisierung
Signifikanztest
Teilbarkeit
Gerade
Computeranimation
DoS-Attacke
Klasse <Mathematik>
Komplex <Algebra>
Code
Signifikanztest
Computeranimation
Rechenschieber
Token-Ring
Framework <Informatik>
Mittelwert
Statistischer Test
Fahne <Mathematik>
Verkehrsinformation
Instantiierung
Rechenschieber
Framework <Informatik>
Klasse <Mathematik>
Rechenschieber
Ordnung <Mathematik>
Signifikanztest
Gerade
Code
Computeranimation
Randomisierung
Patch <Software>
Framework <Informatik>
Klasse <Mathematik>
Reihe
Randomisierung
Ausnahmebehandlung
Signifikanztest
Computeranimation
Einfügungsdämpfung
Sichtenkonzept
Vervollständigung <Mathematik>
Framework <Informatik>
Twitter <Softwareplattform>
Statistischer Test
Stichprobenumfang
Stichprobe
Signifikanztest
Computeranimation
Videokonferenz
Framework <Informatik>
Signifikanztest
Computeranimation

Metadaten

Formale Metadaten

Titel Writing a Test Framework from Scratch
Serientitel RailsConf 2016
Teil 06
Anzahl der Teile 89
Autor Davis, Ryan
Lizenz CC-Namensnennung - Weitergabe unter gleichen Bedingungen 3.0 Unported:
Sie dürfen das Werk bzw. den Inhalt zu jedem legalen und nicht-kommerziellen Zweck nutzen, verändern und in unveränderter oder veränderter Form vervielfältigen, verbreiten und öffentlich zugänglich machen, sofern Sie den Namen des Autors/Rechteinhabers in der von ihm festgelegten Weise nennen und das Werk bzw. diesen Inhalt auch in veränderter Form nur unter den Bedingungen dieser Lizenz weitergeben.
DOI 10.5446/31571
Herausgeber Confreaks, LLC
Erscheinungsjahr 2016
Sprache Englisch

Inhaltliche Metadaten

Fachgebiet Informatik
Abstract Assertions (or expectations) are the most important part of any test framework. How are they written? What happens when one fails? How does a test communicate its results? Past talks have shown how test frameworks work from the very top: how they find, load, select, and run tests. Instead of reading code from the top, we’ll write code from scratch starting with assertions and building up a full test framework. By the end, you'll know how every square inch of your testing framework works.

Ähnliche Filme

Loading...