►
From YouTube: .NET Foundation Project Spotlight - Verify
Description
.NET Foundation Marketing Committee member Isaac Levin spoke to
Simon Cropp, the maintainer of Verify. For more detail, be sure to check out the Project Spotlight page
https://dotnetfoundation.org/projects/spotlight
A
A
B
This
happens
in
several
factors.
The
first
one
is.
It
makes
your
assertion
code
much
simpler,
instead
of
say,
you've
got
a
an
object
that
you're
asserting
you
want
to
assert
the
various
different
states
of
that
prop
multiple
properties
and
everything
on
there.
With
assertion
testing,
it
might
be,
you
know,
10
different
lines
of
assertion
code.
If
you
have
a
loop,
you
might
need
to
loop
through
and
assert
that
all
of
those
things
are
correct
in
the
list.
B
You
can
pass
any
given
instance
of
a.net
object
to
the
snapshot,
testing,
library
and
it
will
serialize
that
to
a
file,
and
then
that
is
what
you
assert
against
in
the
future.
So
the
first
time
you
assert
that
first
time
you
verify
that
file,
it
writes
it
to
disk
and
that's
your
becomes
the
representation
of
what
should
be
in
the
future.
So
it
simplifies
getting
started
with
your
assertions
because
it
it
instantly
shows
you
what
it
looks
like
now
and
you
get
to
choose
if
that's
correct
and
moving
forward
any
test
run
in
the
future.
B
A
A
A
That's
great,
I
mean,
as
somebody
who
is
a
net
developer
and
writing
tests.
Are
you
know
kind
of
one
of
the
last
things
that
we
do
it's
one
of
those
things
that
any
tool
that
can
make
my
life
easier
in
the
testing
space?
I'd
like
to
know
a
little
bit
about
the
origin
of
verify.
So
what
kind
of
led
you
down
this
path
of?
Creating
you
know,
kind
of
a
a
tool
to
you
know:
empower
people
when
they're
building
out
their
tests.
B
B
One
of
the
things
I
found
with
that
is
with
approval
tests.
Is
it
was
written
at
the
time
when
everything
was
attribute
driven,
so
you
think
back
to
the
early
days
of
net,
and
you
know
your
test
libraries
until,
to
a
certain
extent,
now
are
driven
by
attribute
driven
everything's
statically
compiled
and
you
walk
through
those
attributes
and
that
works.
But
it's
not
expressive
enough.
B
So
that
was
one
of
the
things
I
moved
decided
to
fork.
Something
else
out
of
also
approval
test
has
a
significant
user
base
and
one
of
the
tenets
of
approval
tests
is
it
helps
you
test
legacy
code.
So
it's
one
of
the
things
it
really
wants
to
help
you
with,
and
as
part
of
that,
you
get
that
into
your
mindset
and
that
project
really
avoids
making
breaking
changes,
because
if
you
are
testing
legacy
code,
that's
one
of
things
you
want
to
avoid.
B
You
want
to
avoid
having
moving
forcing
people
to
move
forward
and
break
existing
testing
frameworks,
so
it
was.
There
was
just
too
much
history
there.
I
had
to
fork
out
my
learnings
from
that
project
and
come
up
with
something
new
from
scratch,
and
it
was
effectively
from
scratch.
It
was.
It
was
a
new
rewrite
where
each
of
the
concepts
in
approval
tests
I
took
and
reapplied
based
on
you
know
more
modern
learnings
of
how
apis
should
be
written.
A
That's
really
interesting,
I
mean
so
obviously
going
from
something
like
brutal
test.
Like
you
mentioned
kind
of,
has
multi-language
support
right,
even
in
the
in
the
dot-net
world,
like
we're
talking,
you
know
from
a
paradigm
perspective,
tons
of
different
ways.
People
write
apis
tons
of
different
testing
frameworks.
So
you
know
what
has
been
one
of
the
the
biggest
challenge
for
you
as
you've.
You
know
continually
had
to
you
know,
make
sure
it
works
for
this
new
version.
Of.Net
make
sure
it
works.
For
this
you
know
new
hot
testing
framework.
B
Making
work
for
new
versions,
of.net
wasn't
too
much
of
a
hassle
that
wasn't
a
main
blocker,
getting
it
to
work
in
a
seamless
way
with
each
of
the
different
testing
frameworks
was
quite
complex
and
I
think
the
the
challenge
there
is
that,
at
a
top
level,
writing
a
test
in
each
of
the
different
testing
frameworks.
You
can
map
that
across
and
look
at
the
code
and
they
look
fairly
similar,
but
the
extensibility
model
of
each
of
the
different
testing
frameworks.
B
So
I
think
that
different
testing
libs
have
been
much
more,
like
maintained,
so
much
more
free
to
evolve
how
the
extensibility
model
works
in
the
different
testing
libraries
so
how
they
share
the
current
state
of
tests
or
even
if
they
do,
share
the
current
state
of
tests,
how
you
plug
in
and
manipulate
and
get
the
data
out
of
a
context
how
you
force
something
to
fail.
So
that
was
quite
a
challenge,
but
is
it
some
reflection
code
for
some
of
the
test
frameworks
where
you
know
it's
it's
inside
of
knowledge.
B
So
that's
been
a
bit
of
a
challenge
and
another
challenge
I
had
was:
I
recently
added
support
for
expecto,
which
is
a
test
framework
targeting
f-sharp
and
it's
completely
different
to
all
the
other
test
frameworks,
both
from
the
not
just
the
accessibility
model,
but
how
you
even
write
tests.
So
it's
functional
first,
ignore
whatever
testing
frameworks
have
done
and
write
something
that
works
the
best
for
how
people
code
in
f
sharp.
So
that
was
a
significant
challenge
but
yeah
I
got
it
working
in
the
end
with
some
caveats
but
yeah.
A
B
Yes,
so
it's
it
is
purely.net,
there's
nothing
c-sharp
specific
about
it.
It
is
written
in
c-sharp,
so
you
can
consume
so
verify
supports
ms
test
unit
x
unit
and
expecto
in
terms
of
test
libraries
and
you
can
consume
any
of
those
from
c
sharp
v
b,
f,
sharp
or
any
other
dot
net
language.
So
there
are
people
who
are
using
x
unit
in
f,
sharp
and
they're,
using
the
verify
x
unit
library
in
f,
sharp,
and
there
are
some
people
who
are
doing
vb
stuff
as
well.
A
Yeah
I
mean
I
just
can't-
I
can't
even
think
of
a
situation
where
you
know
managing
not
just
one
but
two
but
three
different
languages
right
like
in
making
sure
that
the
paradigms
exist,
especially
when
you're
going
from
you
know
c
sharp
v
b
to
f
sharp
right
I'd.
Imagine
that
you
might
have
had
some
help
along
the
way
right.
Have
you
had
anybody
kind
of
give
you
some.
B
I
had
a
few
people
prompt
me
to
do
the
better
f-sharp
support,
both
in
expecto
and
mbx
unit
one,
and
I
did
get
a
lot
of
pointers
from
the
community.
They
were
very
helpful
in
you
know
both
getting
me
up
to
speed
with
f
sharp
enough
that
I
could
write
samples
providing
me
hints,
and
you
know
walking
through
how
expect
I
work,
so
they
were
quite
helpful
in
getting
that
up
and
running.
B
Vb
vb
is
close
enough
to
c-sharp
in
like
the
paradigm.
It's
still,
you
know
primarily
object-oriented
and
it's
not
it's
not
a
paradigm
shift
as
to
what
f-sharp
is.
So
it's
not
much
of
an
issue.
It
just
just
works,
and
also
people
who
are
coding
in
vb
seem
to
have
become
comfortable
with
reading
samples
in
c
sharp
and
making
that
work
in
vb.
So
I
have
samples
for
documentation,
samples
for
f,
sharp
and
c-sharp.
I
haven't
gone
out
of
vp
path,
yet.
A
That's
awesome
I
mean
so
I'm
glad
to
hear
the
community
saw
verify
is
something
that
can
empower
all
net
developers
right.
So
I
you
know:
if
people
go
and
take
a
look
at
the
github
page
or
they
get
a
repo
for
it
like
you've
had
some
contributors,
you
you're
fairly
active
in
there
right
so
like
what's
next
for
verify,.
B
Well,
next,
I
need
to
I've
done
a
bit
of
a
bit
of
testing
with
net
six.
It's
meant
to
be
out
in
november,
but
I
don't
know
maybe
they're
playing,
I'm
dropping
it
soon
and
looking
at
some
of
the
the
stuff
I've
seen
coming
out
and
making
sure
it
works
with
dot
net
six
will
be
an
important
thing
to
work
on,
but
also
the
getting
it
to
getting
it
to
work
on
different
operating
systems
better
as
well.
B
So
when
you
say
you
serialize
person,
then
the
name
changes
you
have
a
difference
between
the
accepted
snapshot
and
the
one
that
you
currently
have.
So
when
that
happens,
you'll
get
a
diff
tool
pop
up,
so
something
like
beyond
compare
or
any
other
div
tool
that
you
have
installed.
It'll
detect
it
for
you
and
it
will
highlight
the
difference
for
you
and
that
works
okay
for
one
snapshot
for
one
change.
B
You
can
manually
accept
that
in
the
snapshot
tool
or
you
can
manually
rename
the
file
on
disk,
but
that
gets
very
cumbersome
very
quickly
when
you're
managing
many
many
different
snapshot
files
over
and
over,
and
you
want
to
iterate
quickly
so
there's
a
few
different
ways
that
you
can
automate
that
process.
One
is
a
clipboard
approach
where
it
will
put
when
a
snapshot
fails.
It
will
put
the
command
to
accept
that
snapshot
change
into
your
clipboard.
So
if
it
fails
the
diff
engine
pops
up,
you
look
at
it
and
then
you
just
right.
B
B
So
on
on
mac,
you
can
the
clipboard
approach
works
and
the
writer
approach
works
with
the
extension,
but
for
tray
tool
doesn't
and
also
on
mac.
If
you're
on
vs
for
mac,
you
can't
install
resharper
in
that,
so
you
can't
have
the
extension
in
there.
So
there's
a
bit
more
limited
support
on
mac
and
similar
caveats
on
linux.
So
what
I
need
to
do
is
rewrite
that
tray
tool
to
be
cross-platform
so
that
the
same
seamless
experience
and
all
of
the
options
work
on
all
the
different
operating
systems.
A
Development,
well,
hopefully,
that
you
know
you
know
in
the
dot
net
sick,
dot,
net
six
wave-
and
you
know
future
versions
of
dot
net.
You
know
desktop
clients
are
more
and
more.
You
know.
Desktop
clients
across
different
platforms
are
more
and
more
readily
available
right,
like,
for
instance,
with
maui
hope.
Maybe
you'll
get
some
sort
of
availability.
For
you
know,
mac
clients.
B
A
Yeah,
I
mean
you
know:
I'm
not
going
to
speak
whether
you
know
windows
forms
should
still
be
developed
like
new
feature
work,
but
I
mean,
if
you
have,
if
you're
stuck
there,
please,
you
know,
take
advantage
of
the
things
that
dot
net
core
can
do
for
you,
but
maybe
look
at
maui's
an
option
too.
If
you
can
rewrite,
I.
B
Did
I
initially
went
with
windows
forms
for
the
tray
tool
because
it's
something
you're
running
in
memory
resident
all
the
time
on
your
dev
machine?
Well,
that's
how
I
do
so.
You
snap
your
testing
in
in
my
day,
job
and
a
basic
windows
format
starts
blindingly
fast
and
uses
hardly
any
memory
and
for
the
stuff
I
was
doing
it.
It
just
still
works.
I
know
it's
considered
legacy
by
many,
but
yeah.
It
just
works.
A
Oh,
I
I
mean
when
there's
a
reason
why
windows
forms
are
still
used
and
built
as
much
as
they
are
right
like
to
your
point.
Things
are
increasingly
fast.
You
know.
Building
them
is
very,
very
straightforward,
like
the
designers
inside
of
visual
studio
and
resharper
are
great
right,
I'm
sorry
yeah
and
I
think
basically,
it's
if
you
find
the
right
tool
for
the
job
you're
trying
to
do
right,
like
do
you
need
to
you
know,
bring
down
400
dlls
to
be
able
to
write
like
a
little
tray.
A
A
That's
great,
I
mean,
I
think,
that's
very,
very
valuable
right.
You
know,
especially
when
you
come
to
think
about,
like
validation
testing,
for
anything,
whether,
like
you
know
being
able
to
compare
screenshots
of
pages
or
rendered
html
of
pages
or
being
it
like.
I
think
this
concept
allows
a
lot
of
people
to
you
know,
have
an
easier
way,
easier
ability
to
fall
asleep
at
night,
because
you
have
the
ability
to
understand
that
my
builds,
if
my
builds
pass,
that's
great,
but
it's
not
just
my
builds
passing
and
my
test
passing.
A
B
And
and
because
it
commits
those
faster
source
control,
you
have
this
very
interesting
side
effect
happen
where
looking
back
through
history
or
the
previous
versions,
or
changes
between
two
versions,
you
can
now
go
down
to
each
commit
and
say
we
did
this
commit
and
how
did
that
change
the
look
and
feel
of
the
web
page
at
that
time.
So
you
have
it's
much
easier
to
understand
what
a
code
change
has
done
when
you
can
see.
B
B
Here's
the
exact
diff
and
you
can
see
the
before
and
the
after.
Is
that
correct
right?
So
you
have
these
kind
of
flow-on
effects
all
these
different
parts
of
your
business
where,
like
they
don't
know
what
snapshot
testing
is
but
suddenly
you're
surfacing
this
information
at
a
much
higher
level
that
you
can
communicate
with
it's
a
strange
side
effect.
That
happens,
you
don't
need
to
teach
people
about
it.
Just
just
happens.
A
Yeah,
I
mean
just
the
concept
of
being
able,
because,
unfortunately,
like
humans
can't
tell
all
the
subtle
differences
in
two
images,
if
they're
very
similar
right,
but
machines
can
very
very
well
right.
So
being
it
like,
you
know,
for
instance,
if
you
make
a
change
and
a
button
gets
moved
over,
like
five
pixels,
like
most
human
eyes,
aren't
going
to
be
able
to
detect
that,
but
those
five
pixels
might
moving.
That
thing
over
might
be
a
problem
right
so
being
able
to
continuously
compare
against
versions
that
you
know
are
verified
is
really
valuable.
A
B
B
I
I
wouldn't
say,
like
I
think,
a
few
percent
of
projects
use
it
there's,
probably
six
different
snapshot,
testing
libraries
in.net
that
are
currently
in
active
development
and
all
of
those
people
are
happy
to
be
reached
out
to-
and
I
have
done
so
on
social
media
or
in
in
get
github
repositories
and
we've
shared
ideas
and
pulled
different
things
back
and
forth.
So
the
different
libraries
are
kind
of
leveraging
of
things,
they've
learned
and
applying
them
in
their
own
paradigm.
B
B
One
of
the
challenges
of
snapshot
testing
is
you
have
to.
You
often
have
to
see
it
in
action
to
understand
it
properly
and
understand
the
value
and
getting
that
flow.
Correct
is
difficult.
The
first
time
you
do
it,
you
don't
quite
rock
it
until
you've
done
it
three
or
four
times
or
someone
explains
it
who's
walking
through.
So
if
anyone
wants
to
get
on
a
call
with
me,
I
can
show
you
samples.
I
can
help
you
get
started
in
your
own
project.
Just
let
me
know.
A
That's
great,
I
I
really
appreciate
you
coming
on
here
and
chatting
on
something
about
verify
so
folks,
if
you
feel
like
your
testing
framework,
if
you're
testing
projects,
if
you
could
you
know
level
up
them
in
a
way
that
you
know,
allows
you
to
get
that
more
high
fidelity
comparison
of
what's
verified
and,
what's
not,
please
check
out
verify
so
simon.
I
want
to
thank
you
so
much
for
hopping
on
and
saying
hello
and
for
everybody
checking
out
this
page
be
sure
to
check
out
the
verified,
github,
repo
and
all
the
other
assets.