1
00:00:06,030 --> 00:00:12,510
Everybody has gone this is Caleb with slopes dot com and in this video we're going to talk about unit

2
00:00:12,510 --> 00:00:18,060
testing of course but I'm going to show you a project that has already been built and we're basically

3
00:00:18,060 --> 00:00:24,090
going to take that project and add in unit tests to make sure that it's future proved in a way so that

4
00:00:24,090 --> 00:00:30,000
if a new dev were to come on all of our tests would pass and if they added anything that broke that

5
00:00:30,240 --> 00:00:30,910
we would know.

6
00:00:30,930 --> 00:00:34,510
So we're going to go ahead and pull up on our project here.

7
00:00:34,680 --> 00:00:37,470
And it's called the wall calque Aroney.

8
00:00:37,490 --> 00:00:41,100
I don't really know why I named it that but that's what it's named.

9
00:00:41,100 --> 00:00:44,790
And basically it's a simple calculator application.

10
00:00:44,820 --> 00:00:45,530
It's not perfect.

11
00:00:45,540 --> 00:00:50,730
You know it doesn't do decimals yet there are some things that we can expand upon but for the most part

12
00:00:50,760 --> 00:00:57,270
it works you know forty five minus six thirty nine eight times ten.

13
00:00:57,500 --> 00:00:57,980
Eighty.

14
00:00:57,990 --> 00:00:59,570
You know it works for the most part.

15
00:00:59,820 --> 00:01:02,640
Decimal numbers are not yet enabled.

16
00:01:02,640 --> 00:01:03,990
That will be something in the future.

17
00:01:04,080 --> 00:01:08,340
But what I'm going to do is I'm going to walk you through the project really quickly and then we're

18
00:01:08,340 --> 00:01:13,640
going to go ahead and integrate some tests for our calculation manager model.

19
00:01:13,690 --> 00:01:16,170
So let's go ahead and take a look.

20
00:01:16,200 --> 00:01:22,860
Basically our UI you just saw it it has quite a few buttons and a label and a nice little picture of

21
00:01:22,860 --> 00:01:24,180
mountains in the background Dubbs.

22
00:01:24,180 --> 00:01:24,520
Get it.

23
00:01:24,530 --> 00:01:26,120
Mountains anyway.

24
00:01:26,130 --> 00:01:34,050
And so then inside here we have a ton of Iby outlets for all those buttons we have as you know Iby actions

25
00:01:34,050 --> 00:01:41,810
for the number buttons AC button operand button for you know plus minus plus minus.

26
00:01:41,820 --> 00:01:45,020
Multiply and divide and then one for the equals button.

27
00:01:45,090 --> 00:01:52,560
Then we basically create a calculation manager object and we instantiate it in feuded load and we use

28
00:01:52,560 --> 00:01:57,520
the calculation manager to basically do everything regarding numbers and calculations.

29
00:01:57,520 --> 00:01:59,400
OK it's its own little class.

30
00:01:59,430 --> 00:02:07,620
So inside the calculation manager we have a couple of properties we have value a value b k we use that

31
00:02:07,620 --> 00:02:12,830
you know 12 plus 6 value would be 12 value B would be 6.

32
00:02:12,900 --> 00:02:18,030
The operand comes from an enumeration which we'll talk about in just a second and then we have what's

33
00:02:18,030 --> 00:02:20,220
called value entry array.

34
00:02:20,220 --> 00:02:21,980
So there are a few functions in here.

35
00:02:21,990 --> 00:02:24,720
And the first one is called insert.

36
00:02:24,720 --> 00:02:30,950
Basically if value A is equal to zero which it is initially we set value a to be the value that's passed

37
00:02:30,950 --> 00:02:31,770
in.

38
00:02:31,770 --> 00:02:33,620
So let's say we type 12.

39
00:02:33,630 --> 00:02:36,220
We push enter.

40
00:02:36,570 --> 00:02:38,060
That's going to set value.

41
00:02:38,130 --> 00:02:42,930
Then if I come by and I push six value is already equal to 12.

42
00:02:42,930 --> 00:02:46,730
So then it's going to go ahead and set value B to that value which is pretty cool.

43
00:02:47,100 --> 00:02:52,350
So then we have a function in here called Set which basically just sets the operand.

44
00:02:52,350 --> 00:02:58,530
So if we type you know 12 and push Plus set up Rand gets called and the current upper end gets set to

45
00:02:58,630 --> 00:03:01,590
addition and then we call a function called set values.

46
00:03:01,590 --> 00:03:03,200
We'll get to that in a second.

47
00:03:03,300 --> 00:03:08,430
Basically append is a function that's going to append a value to our value a.a.

48
00:03:08,460 --> 00:03:10,030
We'll talk about that as well.

49
00:03:10,110 --> 00:03:12,150
Clear values does what you might think.

50
00:03:12,150 --> 00:03:17,490
It's basically going to be just removing everything it clears the array and it sets all the values back

51
00:03:17,490 --> 00:03:18,370
to 0.

52
00:03:18,420 --> 00:03:20,510
That's useful when pushing the AC button.

53
00:03:20,730 --> 00:03:25,770
And then this function is called the string of five values because of course we're using a label so

54
00:03:25,770 --> 00:03:30,780
we can't put an integer directly into a label so we convert it into a string.

55
00:03:30,780 --> 00:03:31,010
All right.

56
00:03:31,020 --> 00:03:36,450
So then we have the set values function which basically begins with a value string.

57
00:03:36,510 --> 00:03:42,860
Then we take our value a.a which if you look is of type int case we have a bunch of integers.

58
00:03:42,880 --> 00:03:50,180
Basically what we're doing is we are appending each value in that array as a string.

59
00:03:50,340 --> 00:03:59,430
And then we're appending the next character to the same string until we basically have a string of just

60
00:03:59,910 --> 00:04:03,570
the number values that we typed into the calculator.

61
00:04:03,570 --> 00:04:04,940
So it is a string though.

62
00:04:05,070 --> 00:04:08,950
And then what we do is we take the int value.

63
00:04:09,000 --> 00:04:13,720
Basically we take the value string we forecast it as an int and we pass in that value.

64
00:04:13,740 --> 00:04:18,510
Then we clear out the array so that we can have the next value come in of course.

65
00:04:18,520 --> 00:04:25,080
Calculate basically takes all the information and returns a particular value for either add subtract

66
00:04:25,350 --> 00:04:27,090
multiply or divide.

67
00:04:27,090 --> 00:04:34,080
And like I said before the operand Inam is just add subtract multiply and divide and they have number

68
00:04:34,080 --> 00:04:41,160
values just that I could basically identify them easier with a particular value k or I guess with a

69
00:04:41,160 --> 00:04:44,280
button tag in the storyboard.

70
00:04:44,430 --> 00:04:46,590
So that is that.

71
00:04:46,590 --> 00:04:51,370
And now we're going to go ahead and add our test cases really quickly.

72
00:04:51,480 --> 00:04:57,390
And of course you can do this two ways you can either create a new project like so click Create new

73
00:04:57,390 --> 00:05:01,850
project single view app give it a name and then all you have to do is tick.

74
00:05:01,860 --> 00:05:07,130
Include unit test and it'll automatically include a testing target for you.

75
00:05:07,350 --> 00:05:15,900
Or alternatively you can just go up to here type new target and then you're going to scroll down until

76
00:05:15,900 --> 00:05:24,180
you find iOS unit testing bundle and it's common for you to basically you know type your project name

77
00:05:24,300 --> 00:05:26,300
and then follow that up with tests.

78
00:05:26,340 --> 00:05:26,900
That's it.

79
00:05:27,060 --> 00:05:29,610
So it already does this automatically for you.

80
00:05:29,790 --> 00:05:32,390
But if your project was named something different you could change it.

81
00:05:32,400 --> 00:05:34,940
But anyway once you're done click Finish.

82
00:05:34,950 --> 00:05:37,550
And of course that will pop up right here.

83
00:05:37,590 --> 00:05:45,120
Open it up and you'll see it presents you with a swift file and it's called Wall Kelk Aroney tests.

84
00:05:45,120 --> 00:05:48,710
And of course this is for testing the entire project.

85
00:05:48,840 --> 00:05:50,460
But we're not going to be doing that.

86
00:05:50,450 --> 00:05:54,690
We're going to be writing tests for our calculation manager first anyway.

87
00:05:54,810 --> 00:06:00,510
So what we're going to do is we're going to right click Create a new file and it's going to basically

88
00:06:00,510 --> 00:06:03,060
be a unit test case class.

89
00:06:03,120 --> 00:06:10,110
So click that and we're going to go ahead and name it calculation manager tests and then click Next

90
00:06:10,980 --> 00:06:14,860
save it and then basically we can get rid of this old one.

91
00:06:14,940 --> 00:06:18,330
We don't need it anymore and you get rid of that bad boy.

92
00:06:18,570 --> 00:06:19,560
And here we are.

93
00:06:19,560 --> 00:06:24,140
So we have successfully imported X-C test.

94
00:06:24,300 --> 00:06:30,660
We have successfully created a class called calculation manager tests and we have basically inherited

95
00:06:30,660 --> 00:06:35,670
from X-C test case there are two functions here set up and tear down.

96
00:06:35,880 --> 00:06:38,520
Like it says we're going to put set up code here.

97
00:06:38,520 --> 00:06:45,110
This method is called before the invocation of every test method in the class so then we have tear down

98
00:06:45,120 --> 00:06:50,280
like I said earlier tear down code basically rips all of the code down at the end.

99
00:06:50,280 --> 00:06:57,150
So it's a good way to basically reset the state so that you're starting with a fresh state every test.

100
00:06:57,150 --> 00:07:02,690
So we are given to test examples from the beginning we're not going to use these.

101
00:07:02,700 --> 00:07:07,830
But what I want you to know is there is something that is the same about both of these and they both

102
00:07:07,830 --> 00:07:14,520
begin with test that word is a key word and that's how X code knows that a test is beginning.

103
00:07:14,520 --> 00:07:19,680
So if you don't type this it's basically going to register it as an ordinary example.

104
00:07:19,680 --> 00:07:24,600
So if I try to build this you'll notice that little diamond goes away and that diamond is important.

105
00:07:24,600 --> 00:07:31,650
So if I type test example and build it again you'll notice the diamond comes back and if we were to

106
00:07:31,650 --> 00:07:34,280
click this it would run our test.

107
00:07:34,300 --> 00:07:34,880
OK.

108
00:07:34,980 --> 00:07:39,210
Now that's how you how you run an individual test if you want to run all tests.

109
00:07:39,210 --> 00:07:41,320
You can simply click the one on the class.

110
00:07:41,430 --> 00:07:44,780
So if I click that you'll see it will build the project.

111
00:07:44,860 --> 00:07:48,480
It'll pop up in the simulator but it won't run.

112
00:07:48,480 --> 00:07:53,730
It will open it and then basically it'll say it's testing our project and then it quits out.

113
00:07:53,730 --> 00:07:59,960
So as you can tell we have a successful test passed and this test also passed.

114
00:07:59,960 --> 00:08:01,550
However it's a different type of test.

115
00:08:01,560 --> 00:08:06,580
It's a performance test which we can talk about later but it basically said it took zero seconds to

116
00:08:06,610 --> 00:08:09,240
2 to do because there's nothing in it.

117
00:08:09,300 --> 00:08:15,840
So go ahead and actually delete these get rid of this and what we're going to do is we're going to start

118
00:08:16,050 --> 00:08:21,560
by creating an instance of calculation manager but I'm going to use a special keyword.

119
00:08:21,570 --> 00:08:30,110
So go ahead and type var SU t Sutt and then that's going to be of type calculation manager.

120
00:08:30,690 --> 00:08:31,260
OK.

121
00:08:31,500 --> 00:08:38,280
Now if I build this you'll notice the project succeeds but when we get to our tests it says use of undeclared

122
00:08:38,280 --> 00:08:40,080
type calculation manager.

123
00:08:40,230 --> 00:08:43,250
And that's because these two targets are not linked.

124
00:08:43,260 --> 00:08:46,830
Our tests have no way of interacting with our code from our project.

125
00:08:47,010 --> 00:08:52,010
But in order to do that we can go ahead and type at testable OK.

126
00:08:52,050 --> 00:08:58,350
And if we type at testable import we can go ahead and import our project into this test file by typing

127
00:08:58,350 --> 00:09:02,120
the name of our project which is wall Kelk Aroney.

128
00:09:02,430 --> 00:09:04,710
You don't have to name it that that's what I named it.

129
00:09:04,740 --> 00:09:11,130
So if I build and run now you'll see the build succeeds for our project and our calculation manager

130
00:09:11,130 --> 00:09:12,330
shows up properly.

131
00:09:12,600 --> 00:09:17,310
So now we need to go ahead and instantiate calculation manager so that we can use it.

132
00:09:17,400 --> 00:09:24,670
So go ahead and get rid of this comment in the setup function and go ahead and just say oops equals

133
00:09:25,170 --> 00:09:30,540
calculation manager and just create an empty instance of calculation manager.

134
00:09:30,540 --> 00:09:32,140
Something I want you to know though.

135
00:09:32,330 --> 00:09:41,220
Su T is a very very important thing and Su T stands for a system under test and it's a pretty common

136
00:09:41,790 --> 00:09:47,250
way to refer to the system that you're wanting to test and my system is calculation manager so that

137
00:09:47,280 --> 00:09:50,250
is my sut or system under test.

138
00:09:50,280 --> 00:09:53,550
So we have now successfully created a calculation manager.

139
00:09:53,550 --> 00:10:00,450
Now we need to set up our teardown function so that it properly sets our calculation manager to nil

140
00:10:00,630 --> 00:10:03,660
at the end of every test so that we get a fresh instance every time.

141
00:10:03,810 --> 00:10:07,370
So delete that comments and above superdog tear down.

142
00:10:07,370 --> 00:10:10,390
Go ahead and type sut equals nil.

143
00:10:10,440 --> 00:10:13,350
And what that's going to do is it's basically going to make it.

144
00:10:13,350 --> 00:10:15,150
No that's pretty self-explanatory.

145
00:10:15,150 --> 00:10:18,640
So let's begin with our first tests.

146
00:10:18,720 --> 00:10:24,540
What I like to do is I like to open the assistant editor and then open up the actual file that I am

147
00:10:24,540 --> 00:10:25,650
writing test for.

148
00:10:25,650 --> 00:10:32,190
So I'm going to go into my model folder open up my calculation manager here and let's write some tests.

149
00:10:32,220 --> 00:10:37,920
So I basically want to write a test to make sure that when I initialize a calculation manager and give

150
00:10:37,920 --> 00:10:40,660
it values that those values are actually set.

151
00:10:40,680 --> 00:10:42,880
This is a pretty common way to test data models.

152
00:10:43,050 --> 00:10:46,730
So I'm going to go ahead and type phunk test in it.

153
00:10:46,740 --> 00:10:51,450
We're testing the initialization when given values.

154
00:10:51,840 --> 00:10:52,240
OK.

155
00:10:52,260 --> 00:10:57,860
That's the the state or the status like when I give it a value it takes values.

156
00:10:58,080 --> 00:11:02,820
That's the expected result is that it takes our values and they're set properly.

157
00:11:02,820 --> 00:11:10,140
So what we're going to do inside this test is we're going to go ahead and basically set up our own individual

158
00:11:10,140 --> 00:11:15,960
compartmentalize instance of a calculation manager we've already created one appear and we've instantiated

159
00:11:15,960 --> 00:11:16,080
it.

160
00:11:16,080 --> 00:11:18,520
Don't worry that'll be for a separate test.

161
00:11:18,840 --> 00:11:24,780
But what we're going to do is we're going to type let Kelk manager equals calculation manager.

162
00:11:24,780 --> 00:11:31,710
And when I type of parentheses we can instantiate it with a value a value be current operand and value

163
00:11:31,710 --> 00:11:32,700
entry array.

164
00:11:32,700 --> 00:11:34,300
Now that's because this is a struct.

165
00:11:34,320 --> 00:11:37,910
The properties in here automatically create an initializer.

166
00:11:38,010 --> 00:11:42,420
And so let's go ahead and set a value of 10 value B will be 20.

167
00:11:42,420 --> 00:11:48,690
The operand will be how about multiply and the value entery array will just make it an empty array for

168
00:11:48,690 --> 00:11:49,540
now.

169
00:11:49,560 --> 00:11:54,440
So we now have an instance of calculation manager of course it's going to say we're not using it.

170
00:11:54,690 --> 00:12:00,060
And now we're going to go ahead and type ex-city assert equals and we're going to make sure that these

171
00:12:00,060 --> 00:12:02,490
values are actually equal to what we've set.

172
00:12:02,490 --> 00:12:10,170
So go ahead and type ex-city assert equal and type Kelk manager dot value.

173
00:12:10,500 --> 00:12:15,570
And we're setting the other expression to the one that we want to compare it to.

174
00:12:15,570 --> 00:12:19,680
So we're comparing calque manager value to 10.

175
00:12:19,680 --> 00:12:22,580
We're making sure that that value actually was set.

176
00:12:22,590 --> 00:12:26,920
Now if I build this you'll notice that little test Diamond shows up and I click it.

177
00:12:26,940 --> 00:12:33,160
It's going to go ahead and build the project and run our tests so we'll see if our test passes it's

178
00:12:33,510 --> 00:12:37,970
testing and hey look at that test succeeded which is very very cool.

179
00:12:38,070 --> 00:12:39,710
But this is not a complete test.

180
00:12:39,720 --> 00:12:40,550
It's not thorough.

181
00:12:40,560 --> 00:12:46,800
We're only testing one of the values so let's go ahead and let's actually set this up again so that

182
00:12:46,800 --> 00:12:52,200
we can check to see if our you know our calculation is equal.

183
00:12:52,230 --> 00:12:58,150
So go ahead and type ex-city assert equal calque manager value B.

184
00:12:58,410 --> 00:13:02,280
And that should be 20 k let's do this again.

185
00:13:02,430 --> 00:13:07,890
Our current operand when it is not yet an initialized it is optional.

186
00:13:08,010 --> 00:13:14,180
And so I want to make sure that it is not nil so type LCT assert not nil.

187
00:13:14,670 --> 00:13:21,080
And we're going to just verify that Kelk manager dot current operand is not equal to nil.

188
00:13:21,090 --> 00:13:27,100
So if I actually run these tests and by the way you can click this or you can type command you and it'll

189
00:13:27,120 --> 00:13:29,150
run all your test for you.

190
00:13:29,160 --> 00:13:34,460
We're going to go ahead and just make sure that our test here successfully passes.

191
00:13:34,470 --> 00:13:34,910
OK.

192
00:13:35,100 --> 00:13:35,520
Very cool.

193
00:13:35,520 --> 00:13:41,520
So it passes and that means if somehow our initialiser were to change like if I were to just call this

194
00:13:41,520 --> 00:13:42,890
value entry.

195
00:13:42,900 --> 00:13:43,390
OK.

196
00:13:43,560 --> 00:13:46,140
It still will build right it'll still work.

197
00:13:46,140 --> 00:13:49,830
Of course it'll throw some errors in here but our test will fail.

198
00:13:49,830 --> 00:13:52,440
Meaning that something did not work or something broke.

199
00:13:52,440 --> 00:13:54,770
Which is exactly what we want to be testing.

200
00:13:54,780 --> 00:13:58,450
Now there is a much better way to do this.

201
00:13:58,470 --> 00:14:03,900
I have three asserts here but I could very easily convert this into a single assertion.

202
00:14:03,900 --> 00:14:09,510
Now what I'm going to do is I'm going to go ahead and set my calculation manager struck to conform to

203
00:14:09,510 --> 00:14:16,320
the equatable protocol and if I try to build this it'll say hey it does not conform to the protocol

204
00:14:16,340 --> 00:14:17,210
equatable.

205
00:14:17,400 --> 00:14:22,950
So therefore we need to add protocol stubs and so click fix and it's going to create a static function

206
00:14:23,220 --> 00:14:30,270
inside our struct that basically compares one instance of calculation manager to another.

207
00:14:30,270 --> 00:14:32,370
We have L.H. us and our H.S..

208
00:14:32,370 --> 00:14:38,520
So what we're going to do is basically we're going to go ahead and return true.

209
00:14:38,970 --> 00:14:41,540
Well we want to return TRUE saying they're equal.

210
00:14:41,760 --> 00:14:47,870
But if for some reason one value is not equal to another value it's going to return false.

211
00:14:47,870 --> 00:14:49,150
So just follow me here.

212
00:14:49,260 --> 00:14:54,990
We're going to return true saying that one instance of calculation manager is equal to another.

213
00:14:55,200 --> 00:14:56,360
But we need to make sure.

214
00:14:56,460 --> 00:15:03,810
So if LH us dot value a is not equal to another instance.

215
00:15:03,810 --> 00:15:09,300
All right not value a return false.

216
00:15:09,340 --> 00:15:09,850
OK.

217
00:15:10,150 --> 00:15:14,580
So what we're saying hey if our values are not equivalent return false.

218
00:15:14,710 --> 00:15:15,280
OK.

219
00:15:15,310 --> 00:15:25,570
Now we can do that for value b current operand and value A.H. So if LH US DOT value B is not equal to

220
00:15:25,780 --> 00:15:33,080
our H.S. datt value B will return false.

221
00:15:33,180 --> 00:15:43,820
Ok will do it again if LHO s dot current operand is not equal to r h s current operand.

222
00:15:44,710 --> 00:15:48,310
Turn false and I'm sure there is a much more elegant way of doing this.

223
00:15:48,310 --> 00:15:49,210
This just kind of works.

224
00:15:49,210 --> 00:15:53,450
Kind of a quick and dirty method and then we have what value entry right.

225
00:15:53,690 --> 00:15:56,070
Yeah is not equal to our chest.

226
00:15:56,170 --> 00:16:00,110
Value entery array return false.

227
00:16:00,220 --> 00:16:04,340
So what we can do is we can basically get rid of all of these assertions.

228
00:16:04,420 --> 00:16:08,790
We can create Kelk manager one and calc.

229
00:16:08,800 --> 00:16:10,360
Manager to.

230
00:16:10,810 --> 00:16:14,020
And we can basically set them up to be the same.

231
00:16:14,020 --> 00:16:16,450
So I'm going actually just copy this and paste this.

232
00:16:16,450 --> 00:16:18,490
You're probably thinking Hey what is the point of this.

233
00:16:18,640 --> 00:16:19,290
But check it out.

234
00:16:19,330 --> 00:16:25,240
X TC assert equal we can say calc manager 1 and calc manager 2.

235
00:16:25,240 --> 00:16:33,250
We can actually compare two instances of the same class and see if they actually are what we say they

236
00:16:33,250 --> 00:16:34,190
are which is equal.

237
00:16:34,180 --> 00:16:35,270
They're identical.

238
00:16:35,320 --> 00:16:38,860
So let's actually let's make it fail first let's make value a 5.

239
00:16:39,070 --> 00:16:42,840
Let's BuildOn run and our test should fail.

240
00:16:42,850 --> 00:16:44,180
They should not be equal.

241
00:16:44,320 --> 00:16:49,900
So the build succeeded but when the test run it's going to say hey this failed.

242
00:16:50,110 --> 00:16:51,030
And why is that.

243
00:16:51,030 --> 00:16:52,650
Check it out.

244
00:16:52,840 --> 00:16:56,120
The error here that showing up is really not there.

245
00:16:56,140 --> 00:16:57,160
That's a bug.

246
00:16:57,160 --> 00:16:59,840
By the way X-C test is pretty buggy.

247
00:16:59,860 --> 00:17:02,750
The actual assertion failed but the equivalence worked.

248
00:17:02,770 --> 00:17:04,430
We just forgot to build it beforehand.

249
00:17:04,600 --> 00:17:10,110
Sometimes errors get stuck and you'll just see me kind of return down and then the code will re compile

250
00:17:10,110 --> 00:17:10,960
there and it'll work.

251
00:17:10,960 --> 00:17:15,480
So anyway it says that these two instances are not equal.

252
00:17:15,490 --> 00:17:22,220
But if I make them equal and then rerun the test with command you we should see that the test will run.

253
00:17:22,220 --> 00:17:27,370
It will build and the test should pass look at that they passed.

254
00:17:27,370 --> 00:17:36,200
So basically we now can run our test we can check between two instances when we give it values it takes

255
00:17:36,200 --> 00:17:38,280
values they're all properly set.

256
00:17:38,280 --> 00:17:39,200
Now we've tested both.

257
00:17:39,200 --> 00:17:40,370
So there we go.

258
00:17:40,370 --> 00:17:41,780
Very cool stuff.

259
00:17:41,780 --> 00:17:45,830
And you know what we're going to actually head over to the next video now where we're going to continue

260
00:17:45,830 --> 00:17:52,790
testing our calculation manager where we're going to test that our values are initially 0 K and our

261
00:17:52,790 --> 00:17:53,590
calculation manager.

262
00:17:53,600 --> 00:17:55,750
We're going to verify that they're actually zero.

263
00:17:55,820 --> 00:18:00,960
We're going to verify that inserting a value actually changes the value of value.

264
00:18:01,010 --> 00:18:02,660
OK we've got a lot more testing right.

265
00:18:02,750 --> 00:18:06,040
So let's go ahead and let's head over to the next video and let's do that now.