Add files using upload-large-folder tool

.gitattributes

@@ -73,3 +73,10 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 09[[:space:]]-[[:space:]]Iteration[[:space:]]Statements[[:space:]](Loops)[[:space:]]in[[:space:]]Java/006[[:space:]]Jump[[:space:]]Statements[[:space:]]-[[:space:]]Break[[:space:]]and[[:space:]]Continue.mp4 filter=lfs diff=lfs merge=lfs -text
 09[[:space:]]-[[:space:]]Iteration[[:space:]]Statements[[:space:]](Loops)[[:space:]]in[[:space:]]Java/007[[:space:]]Labels[[:space:]]in[[:space:]]Java.mp4 filter=lfs diff=lfs merge=lfs -text
 09[[:space:]]-[[:space:]]Iteration[[:space:]]Statements[[:space:]](Loops)[[:space:]]in[[:space:]]Java/011[[:space:]]Homework[[:space:]]review[[:space:]]Iteration[[:space:]]Statements[[:space:]](Loops).mp4 filter=lfs diff=lfs merge=lfs -text
+10[[:space:]]-[[:space:]]Methods[[:space:]]in[[:space:]]Java/001[[:space:]]Methods[[:space:]]in[[:space:]]Java[[:space:]]Overview.mp4 filter=lfs diff=lfs merge=lfs -text
+10[[:space:]]-[[:space:]]Methods[[:space:]]in[[:space:]]Java/003[[:space:]]Recursive[[:space:]]methods.mp4 filter=lfs diff=lfs merge=lfs -text
+10[[:space:]]-[[:space:]]Methods[[:space:]]in[[:space:]]Java/004[[:space:]]Variable[[:space:]]Length[[:space:]]Arguments.mp4 filter=lfs diff=lfs merge=lfs -text
+10[[:space:]]-[[:space:]]Methods[[:space:]]in[[:space:]]Java/002[[:space:]]Parameter[[:space:]]Passing[[:space:]]Mechanism[[:space:]]in[[:space:]]Java.mp4 filter=lfs diff=lfs merge=lfs -text
+10[[:space:]]-[[:space:]]Methods[[:space:]]in[[:space:]]Java/016[[:space:]]Homework[[:space:]]review[[:space:]]Methods.mp4 filter=lfs diff=lfs merge=lfs -text
+101[[:space:]]-[[:space:]]Manage[[:space:]]a[[:space:]]Scrum[[:space:]]Team[[:space:]]with[[:space:]]ChatGPT/001[[:space:]]Managing[[:space:]]Scrum[[:space:]]&[[:space:]]Risk[[:space:]]Management[[:space:]]with[[:space:]]Custom[[:space:]]Bot,[[:space:]]Slack[[:space:]]&[[:space:]]GPT.mp4 filter=lfs diff=lfs merge=lfs -text
+100[[:space:]]-[[:space:]]GPT[[:space:]]+[[:space:]]Slack[[:space:]]+[[:space:]]Jira[[:space:]]+[[:space:]]Gmail[[:space:]]Integration/002[[:space:]]Generate[[:space:]]Tickets[[:space:]]in[[:space:]]Jira[[:space:]]&[[:space:]]Send[[:space:]]Email[[:space:]]from[[:space:]]Slack[[:space:]]via[[:space:]]Chat[[:space:]]Interface.mp4 filter=lfs diff=lfs merge=lfs -text

10 - Methods in Java/001 Methods in Java Overview.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:627a31a23e2811b65840db0629a054ddc13f14f3a877e264d29c67769ffc0d31
+size 38302045

10 - Methods in Java/002 Parameter Passing Mechanism in Java.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a317e8b4d649b65e1182aac23e829430c7491bb6d9049972ca8053090548fa1b
+size 61515873

10 - Methods in Java/003 Recursive methods.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b79a2d8b1a9611e02b4a2af70a144b03c73ac10daf48b171c447bc13d039a6be
+size 22474004

10 - Methods in Java/004 Variable Length Arguments.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:500960247a70e5e1815e9620c00473673fec3ec3e8eb554fce153dc47e34e89f
+size 38829454

10 - Methods in Java/016 Homework review Methods.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2ec3836738219c901096ee674e66f44e2e9f960253bb06daff4d22f79662f2e9
+size 8842296

100 - GPT + Slack + Jira + Gmail Integration/002 Generate Tickets in Jira & Send Email from Slack via Chat Interface.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:21ad7a31a0e9fd6236fffe7d2bf533cb8682f6ae66f22b9680c36882ecf26e21
+size 378985718

101 - Manage a Scrum Team with ChatGPT/001 Managing Scrum & Risk Management with Custom Bot, Slack & GPT.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dbc23537524bf7d13d3b47c5531f3c16825d31cc175e7d2950490ee42919cfcb
+size 114695073

30 - Java Reflection API/001 Source-code-of-example-from-the-lesson.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/reflection/Demo.java

30 - Java Reflection API/002 Annotations_en.srt

@@ -0,0 +1,1072 @@
+1
+00:00:06,000 --> 00:00:06,000
+Hello, Jim.
+
+2
+00:00:06,000 --> 00:00:12,000
+Today we're going to learn with you what annotations are, how to work with them and how to create new
+
+3
+00:00:12,000 --> 00:00:12,000
+ones.
+
+4
+00:00:12,000 --> 00:00:18,000
+Before we start this lesson, I must say that it is critically important you watching previous lesson
+
+5
+00:00:18,000 --> 00:00:20,000
+about Reflection API.
+
+6
+00:00:20,000 --> 00:00:26,000
+If you skip that one, please make sure you watch it, because in this lesson, we are going to use
+
+7
+00:00:26,000 --> 00:00:29,000
+Réflexion API to work with annotations.
+
+8
+00:00:29,000 --> 00:00:35,000
+Basically, there is not so much as a ways for us to take advantage from annotations without knowing
+
+9
+00:00:35,000 --> 00:00:36,000
+the Reflection API.
+
+10
+00:00:37,000 --> 00:00:39,000
+In this lesson, we're going to learn everything.
+
+11
+00:00:39,000 --> 00:00:45,000
+The related to annotations will start from the definition of annotation, make you understand what annotations
+
+12
+00:00:45,000 --> 00:00:47,000
+are on the standard banner.
+
+13
+00:00:47,000 --> 00:00:53,000
+We are going to discuss use cases when annotations may be applied and for what purposes.
+
+14
+00:00:53,000 --> 00:00:57,000
+After that, we will start reviewing of the source code examples.
+
+15
+00:00:57,000 --> 00:01:02,000
+I will explain you what targets annotation is and what retention annotation is.
+
+16
+00:01:02,000 --> 00:01:09,000
+We are going to create our own custom annotation and you are going to understand how to create it and
+
+17
+00:01:09,000 --> 00:01:09,000
+process it.
+
+18
+00:01:10,000 --> 00:01:15,000
+And at the end of the lesson, I will also explain you how to create repeatable annotations.
+
+19
+00:01:15,000 --> 00:01:16,000
+Let's stop.
+
+20
+00:01:17,000 --> 00:01:20,000
+And the first question that we have to answer sounds like this.
+
+21
+00:01:21,000 --> 00:01:22,000
+What is annotation?
+
+22
+00:01:22,000 --> 00:01:27,000
+Annotation as a form of metadata provides data about programs.
+
+23
+00:01:27,000 --> 00:01:30,000
+It is not part of the program itself.
+
+24
+00:01:30,000 --> 00:01:35,000
+Annotations have no direct effect on the operation of the court.
+
+25
+00:01:35,000 --> 00:01:38,000
+They annotate the understands this definition.
+
+26
+00:01:39,000 --> 00:01:40,000
+The know what is metadata.
+
+27
+00:01:41,000 --> 00:01:50,000
+Metadata is a data that provides information about other data or similar data about data in program,
+
+28
+00:01:50,000 --> 00:01:57,000
+and we can annotate types, colossus and interfaces, fields, masses, parameters, constructors,
+
+29
+00:01:57,000 --> 00:02:01,000
+local variables, packages, modules and others.
+
+30
+00:02:01,000 --> 00:02:04,000
+We can even annotate annotation itself.
+
+31
+00:02:05,000 --> 00:02:11,000
+Basically, there might be cases when you need to provide more information about your code and use this
+
+32
+00:02:11,000 --> 00:02:18,000
+information on different stages on the level of the source code during compilation and at this stage
+
+33
+00:02:18,000 --> 00:02:18,000
+of the runtime.
+
+34
+00:02:19,000 --> 00:02:25,000
+Late in the lesson we are going to learn this case are some examples I will show you where notation
+
+35
+00:02:25,000 --> 00:02:29,000
+can be applied and how long it will be retained.
+
+36
+00:02:29,000 --> 00:02:36,000
+You already understood what metadata is and what annotation is, but probably it is still not clear
+
+37
+00:02:36,000 --> 00:02:42,000
+for you how this can be helpful and when we need to use annotations in which cases.
+
+38
+00:02:42,000 --> 00:02:45,000
+The first one is information for the compiler.
+
+39
+00:02:46,000 --> 00:02:53,000
+Annotations can be used by the compiler to detect errors or suppress warnings, for example, such popular
+
+40
+00:02:53,000 --> 00:02:54,000
+annotation as override.
+
+41
+00:02:55,000 --> 00:03:02,000
+I am sure you used it already is on purpose or it just added it instead of you overwrite annotation
+
+42
+00:03:02,000 --> 00:03:05,000
+discarded by the compiler during the compilation.
+
+43
+00:03:05,000 --> 00:03:09,000
+And there is a specific purpose of this net information.
+
+44
+00:03:09,000 --> 00:03:14,000
+As you remember, annotation tells us that this method should override method from parent type.
+
+45
+00:03:15,000 --> 00:03:22,000
+Thus, there are specific requirements to access modify which that matter signature and the list of
+
+46
+00:03:22,000 --> 00:03:23,000
+potential exceptions.
+
+47
+00:03:23,000 --> 00:03:32,000
+There is a logical place in juju that analyzes this matter information basically for all methods marked
+
+48
+00:03:32,000 --> 00:03:34,000
+with overrides, this logic is applied.
+
+49
+00:03:35,000 --> 00:03:37,000
+Compile time and deployment time.
+
+50
+00:03:37,000 --> 00:03:45,000
+Processing software tools can process annotation information to generate code, XML files and so forth.
+
+51
+00:03:45,000 --> 00:03:51,000
+For example, such book in the library and do as number in case you have never worked with.
+
+52
+00:03:51,000 --> 00:03:51,000
+No.
+
+53
+00:03:52,000 --> 00:03:53,000
+I will tell you about it.
+
+54
+00:03:53,000 --> 00:03:59,000
+It generates getters and setters for you and also helps you with generating other things.
+
+55
+00:04:00,000 --> 00:04:05,000
+This mechanism also built on top of annotations and reflection API.
+
+56
+00:04:05,000 --> 00:04:12,000
+Basically, you can annotate type was information about methods if you need to be generated, for example.
+
+57
+00:04:12,000 --> 00:04:19,000
+And when you compile your application and upload classes into Java, those masses that you want it to
+
+58
+00:04:19,000 --> 00:04:21,000
+be generated are there on place.
+
+59
+00:04:22,000 --> 00:04:23,000
+Is that clear?
+
+60
+00:04:24,000 --> 00:04:27,000
+And that's a use case of using annotations is runtime processing.
+
+61
+00:04:28,000 --> 00:04:31,000
+Some annotations are available to be excellent at runtime.
+
+62
+00:04:32,000 --> 00:04:35,000
+You can set configuration to retain annotations.
+
+63
+00:04:35,000 --> 00:04:39,000
+Zero zero runtime I will show you is this an example?
+
+64
+00:04:39,000 --> 00:04:41,000
+But let's understand why do we need this?
+
+65
+00:04:42,000 --> 00:04:48,000
+You may need to keep annotations during the runtime to build some logic around this meta information.
+
+66
+00:04:48,000 --> 00:04:50,000
+You're in the program execution.
+
+67
+00:04:50,000 --> 00:04:53,000
+Your homework will be related to this case.
+
+68
+00:04:53,000 --> 00:04:58,000
+I believe that we have learned enough basics to start review and examples.
+
+69
+00:04:58,000 --> 00:05:02,000
+Anyway, I will explain examples as we go and the true.
+
+70
+00:05:02,000 --> 00:05:08,000
+Who believes that understanding of this topic will be easier with source code and the real good examples,
+
+71
+00:05:08,000 --> 00:05:14,000
+rather than with slides for the sake of the demo and this lesson, I created a separate package and
+
+72
+00:05:14,000 --> 00:05:15,000
+separate them a file.
+
+73
+00:05:16,000 --> 00:05:19,000
+You can find them a file in annotations package.
+
+74
+00:05:20,000 --> 00:05:21,000
+Let's start from basics.
+
+75
+00:05:22,000 --> 00:05:24,000
+Let's discuss annotation format.
+
+76
+00:05:24,000 --> 00:05:29,000
+Each annotation is started with at sign, followed by some meaningful name.
+
+77
+00:05:30,000 --> 00:05:36,000
+Z Sign character indicates as a compiler that what follows is an annotation.
+
+78
+00:05:36,000 --> 00:05:41,000
+The annotation can include elements which can be named and zem values.
+
+79
+00:05:41,000 --> 00:05:48,000
+For those elements, elements may contain additional information like in this case, you can see that
+
+80
+00:05:48,000 --> 00:05:50,000
+are used to suppress warnings.
+
+81
+00:05:50,000 --> 00:05:54,000
+Annotation and element value has value types.
+
+82
+00:05:54,000 --> 00:06:01,000
+This is basically for compiler to remove warnings for parameterized, at least in case I would Corman's
+
+83
+00:06:01,000 --> 00:06:02,000
+this annotation.
+
+84
+00:06:02,000 --> 00:06:08,000
+There will be warnings you as a compilation that I am using parameter types without parameter Ryzens.
+
+85
+00:06:09,000 --> 00:06:17,000
+You see this OK and other possible syntax of the similar annotation in case there is only one element
+
+86
+00:06:17,000 --> 00:06:19,000
+is declared inside the annotation.
+
+87
+00:06:20,000 --> 00:06:25,000
+You can omit element key and just put value like in this example.
+
+88
+00:06:25,000 --> 00:06:32,000
+It is also possible to use multiple annotations at once and from Java version eight zero even supports
+
+89
+00:06:32,000 --> 00:06:34,000
+of repeatable annotations.
+
+90
+00:06:34,000 --> 00:06:40,000
+As you can see in this example, a little bit later in our lesson, one will comp the creation of our
+
+91
+00:06:40,000 --> 00:06:41,000
+custom annotations.
+
+92
+00:06:41,000 --> 00:06:44,000
+I will explain you how to create repeatable annotations.
+
+93
+00:06:45,000 --> 00:06:47,000
+Let's open the source code of any annotation.
+
+94
+00:06:48,000 --> 00:06:51,000
+For example, let's look at suppress warnings annotation.
+
+95
+00:06:52,000 --> 00:06:55,000
+As you can see, there is no end in logic and code here.
+
+96
+00:06:56,000 --> 00:07:00,000
+There is no any algorithm or data processing or anything else.
+
+97
+00:07:01,000 --> 00:07:10,000
+Some students ask me then how annotations work, how overwrite annotation works, and all this basically
+
+98
+00:07:10,000 --> 00:07:15,000
+annotations are nothing more than just an information and what you can do.
+
+99
+00:07:15,000 --> 00:07:16,000
+Learn this information.
+
+100
+00:07:17,000 --> 00:07:21,000
+This is up to you, and this logic is programmed in a separate place.
+
+101
+00:07:21,000 --> 00:07:24,000
+OK, that was annotations basics.
+
+102
+00:07:24,000 --> 00:07:29,000
+Now, you know, at least on the high level, what annotations are us?
+
+103
+00:07:29,000 --> 00:07:33,000
+Know known annotations deeper and to learn them better?
+
+104
+00:07:34,000 --> 00:07:36,000
+Let's create our own annotation.
+
+105
+00:07:36,000 --> 00:07:44,000
+If you are already familiar with G-Unit will implement our own kind of test annotation if you are not
+
+106
+00:07:44,000 --> 00:07:45,000
+familiar with your units yet.
+
+107
+00:07:45,000 --> 00:07:46,000
+Just a few words.
+
+108
+00:07:47,000 --> 00:07:49,000
+G-Unit is a framework for unit testing.
+
+109
+00:07:50,000 --> 00:07:56,000
+It provides a lot of different features and the Mournes impossibility to run specific methods separately
+
+110
+00:07:57,000 --> 00:07:59,000
+to execute separate test cases.
+
+111
+00:07:59,000 --> 00:08:06,000
+The purpose of that massive is to reproduce the state of the system as a specific moment of time, and
+
+112
+00:08:06,000 --> 00:08:08,000
+the Cert is expected to be here.
+
+113
+00:08:09,000 --> 00:08:15,000
+All examples will be stored under this package, so you will easily found them in attachments to this
+
+114
+00:08:15,000 --> 00:08:17,000
+lesson in case you want to run examples on your computer.
+
+115
+00:08:18,000 --> 00:08:19,000
+Let's start.
+
+116
+00:08:19,000 --> 00:08:21,000
+I create test annotations.
+
+117
+00:08:21,000 --> 00:08:28,000
+First, I declare annotation in a separate file, and you can see in this example that the use interface
+
+118
+00:08:28,000 --> 00:08:30,000
+here was at sign.
+
+119
+00:08:31,000 --> 00:08:38,000
+The second important step is to add matter annotations to specify the scope and the target of our custom
+
+120
+00:08:38,000 --> 00:08:38,000
+annotation.
+
+121
+00:08:39,000 --> 00:08:43,000
+I'm talking about annotations, zero retention and target.
+
+122
+00:08:44,000 --> 00:08:44,000
+Let's run.
+
+123
+00:08:44,000 --> 00:08:45,000
+What are they?
+
+124
+00:08:46,000 --> 00:08:48,000
+So what do we need to target annotation for?
+
+125
+00:08:49,000 --> 00:08:54,000
+This annotation indicates a context in which an annotation type is applicable.
+
+126
+00:08:55,000 --> 00:09:02,000
+In simple words, where you can use the sanitation target, annotation can take array of any values
+
+127
+00:09:02,000 --> 00:09:04,000
+of element type enum.
+
+128
+00:09:05,000 --> 00:09:08,000
+So even in case you forgot where you can use annotations.
+
+129
+00:09:09,000 --> 00:09:16,000
+Just open element type in them and you would find enum for each possible placement of your annotation.
+
+130
+00:09:16,000 --> 00:09:24,000
+Even despite the fact is, a on annotation may take array of elements in our specific example, we would
+
+131
+00:09:24,000 --> 00:09:33,000
+use only one in a message because in our specific business context, we don't want to allow our client
+
+132
+00:09:33,000 --> 00:09:37,000
+use it in other places is an exhortation is retention.
+
+133
+00:09:38,000 --> 00:09:43,000
+This information indicates how long annotations was annotated.
+
+134
+00:09:43,000 --> 00:09:45,000
+Time are to be retained.
+
+135
+00:09:45,000 --> 00:09:49,000
+That is exactly what we have discussed at the beginning of our lesson.
+
+136
+00:09:49,000 --> 00:09:56,000
+When I explained that annotation may be used during Zabeel time by the compiler and discarded from the
+
+137
+00:09:56,000 --> 00:10:02,000
+class on the glass level but discarded during the anthem, one class is uploaded in.
+
+138
+00:10:03,000 --> 00:10:11,000
+And during runtime, this annotation can take any value of retention policy in them, even in case you
+
+139
+00:10:11,000 --> 00:10:17,000
+forgot what's retention levels for annotations are, you always can open the source code of this in
+
+140
+00:10:17,000 --> 00:10:19,000
+them and explore this.
+
+141
+00:10:19,000 --> 00:10:22,000
+As I said, there's three possible options here.
+
+142
+00:10:22,000 --> 00:10:31,000
+They are source Closs, and one time in our case, we use runtime retention policy because we need this
+
+143
+00:10:31,000 --> 00:10:33,000
+annotation to be retained.
+
+144
+00:10:33,000 --> 00:10:34,000
+That's a runtime.
+
+145
+00:10:34,000 --> 00:10:41,000
+Now, at this time, to add custom elements, imagine that you want to specify expected exception in
+
+146
+00:10:41,000 --> 00:10:47,000
+order we can test negative scenarios, for example, in case we expect exception to be thrown.
+
+147
+00:10:47,000 --> 00:10:49,000
+But there was no any exception.
+
+148
+00:10:49,000 --> 00:10:58,000
+Drone zones This particular test should be considered as field and the stanzas declare an element in
+
+149
+00:10:58,000 --> 00:10:58,000
+annotation.
+
+150
+00:10:58,000 --> 00:11:02,000
+We have to declare mass was the name of the element itself.
+
+151
+00:11:03,000 --> 00:11:06,000
+Return type will be the type of the element.
+
+152
+00:11:06,000 --> 00:11:12,000
+For example, in this specific case, we would like to specify loss of the expected exception.
+
+153
+00:11:12,000 --> 00:11:18,000
+Thus, returns type for this message will be close when we declare this matter.
+
+154
+00:11:18,000 --> 00:11:24,000
+We should remember important things, since this massive can throw an exception.
+
+155
+00:11:24,000 --> 00:11:27,000
+There is a restriction on the return types.
+
+156
+00:11:28,000 --> 00:11:35,000
+Basically, you can return on your primitives string class in them, annotations and arrays of these
+
+157
+00:11:35,000 --> 00:11:36,000
+types.
+
+158
+00:11:36,000 --> 00:11:39,000
+Also, this must has default value.
+
+159
+00:11:40,000 --> 00:11:46,000
+For example, in this particular case, default exception, to be certain is of non plus.
+
+160
+00:11:46,000 --> 00:11:51,000
+This is our custom clause that extends Roble and that basically is empty.
+
+161
+00:11:52,000 --> 00:11:56,000
+This is needed because I can't have default no values.
+
+162
+00:11:56,000 --> 00:12:03,000
+But in case I wouldn't specify, a default value client will be forced to parse the value for this element.
+
+163
+00:12:03,000 --> 00:12:07,000
+But what clients should Boston in case there is no expected exception?
+
+164
+00:12:07,000 --> 00:12:10,000
+That's why I have default non clause here.
+
+165
+00:12:11,000 --> 00:12:14,000
+Similar example of default value in our other element.
+
+166
+00:12:15,000 --> 00:12:19,000
+Each test can be named and default name is empty string.
+
+167
+00:12:19,000 --> 00:12:23,000
+But the client of this code can pass any custom name.
+
+168
+00:12:23,000 --> 00:12:26,000
+One of the restriction was regards the default value.
+
+169
+00:12:26,000 --> 00:12:27,000
+It can't be null.
+
+170
+00:12:28,000 --> 00:12:29,000
+Is that clear?
+
+171
+00:12:29,000 --> 00:12:32,000
+We are done with annotation creation.
+
+172
+00:12:32,000 --> 00:12:34,000
+Let's now understand how to use it.
+
+173
+00:12:35,000 --> 00:12:39,000
+As you can notice, there is no logic defined in the annotation.
+
+174
+00:12:39,000 --> 00:12:46,000
+That means that I should have some place where logic for annotation process is described in this particular
+
+175
+00:12:46,000 --> 00:12:47,000
+example.
+
+176
+00:12:47,000 --> 00:12:53,000
+It can be some tests around the class similar to the G unit, where we have separate runners that can
+
+177
+00:12:53,000 --> 00:12:55,000
+execute my tests.
+
+178
+00:12:56,000 --> 00:12:58,000
+I open tests around the class.
+
+179
+00:12:58,000 --> 00:13:01,000
+It has run tests massive that takes class.
+
+180
+00:13:01,000 --> 00:13:05,000
+It contains tests to run as mass argument.
+
+181
+00:13:05,000 --> 00:13:11,000
+I use this reference to a class object to get the array of all masses.
+
+182
+00:13:11,000 --> 00:13:18,000
+After that, I feel the masses to keep in-stream only masses that have test annotation.
+
+183
+00:13:18,000 --> 00:13:24,000
+After that, I filter all static masses to keep only non static masses in the stream.
+
+184
+00:13:24,000 --> 00:13:28,000
+And now I need to call test my asset on the object.
+
+185
+00:13:28,000 --> 00:13:31,000
+I create new instance using test class.
+
+186
+00:13:32,000 --> 00:13:39,000
+After that, I need to speak logic for annotations that have expected exception and those who don't.
+
+187
+00:13:39,000 --> 00:13:42,000
+You remember that annotations results?
+
+188
+00:13:42,000 --> 00:13:47,000
+Bits of fired by client exception still has exception was not by default.
+
+189
+00:13:48,000 --> 00:13:55,000
+I use this information during implementation of my logic because in case I expect any exceptions specified
+
+190
+00:13:55,000 --> 00:14:02,000
+by client other than default, I need to check that the expected exception has been thrown come back
+
+191
+00:14:02,000 --> 00:14:04,000
+losses of exceptions thrown.
+
+192
+00:14:04,000 --> 00:14:06,000
+Here is the logic for that.
+
+193
+00:14:07,000 --> 00:14:15,000
+By the way, in a reflection API in case exception has been thrown on the invoked received in the invocation
+
+194
+00:14:15,000 --> 00:14:20,000
+target exception that serves as a wrapper for a regional exception.
+
+195
+00:14:21,000 --> 00:14:29,000
+That's why I need to get course massive here to get the reference to the exception that caused invocation
+
+196
+00:14:29,000 --> 00:14:34,000
+target exception in case I don't expect exception to this rule.
+
+197
+00:14:34,000 --> 00:14:41,000
+Massad just should be executed successfully, and I just invoke mass differently.
+
+198
+00:14:41,000 --> 00:14:47,000
+This is not the full replica of test annotation from G-Unit, but we have a goal in this lesson not
+
+199
+00:14:47,000 --> 00:14:53,000
+to run G-Unit, but to understand how to work with annotations and process zap.
+
+200
+00:14:54,000 --> 00:14:57,000
+Now let me show you class with tests.
+
+201
+00:14:57,000 --> 00:15:00,000
+I open the glass, such as code test samples.
+
+202
+00:15:01,000 --> 00:15:02,000
+This class contains.
+
+203
+00:15:02,000 --> 00:15:05,000
+Is different mascots that are marked with test annotation.
+
+204
+00:15:06,000 --> 00:15:09,000
+Each test has name for the sake of the current demo.
+
+205
+00:15:09,000 --> 00:15:17,000
+I have two test cases here mascots that is executed without exception and massive that throws exception
+
+206
+00:15:17,000 --> 00:15:18,000
+of expected type.
+
+207
+00:15:19,000 --> 00:15:20,000
+Nothing complex here.
+
+208
+00:15:21,000 --> 00:15:27,000
+And now let's write a code that will use my test runner to run these test cases.
+
+209
+00:15:28,000 --> 00:15:32,000
+I open another clause at the so-called test annotation demo.
+
+210
+00:15:33,000 --> 00:15:34,000
+I read instance of test runner.
+
+211
+00:15:35,000 --> 00:15:44,000
+I could run test method and the person's glass that contains my test cases that so let's run this program
+
+212
+00:15:44,000 --> 00:15:45,000
+and console.
+
+213
+00:15:45,000 --> 00:15:53,000
+You can see that test without exception has been passed because we received exception that we expect
+
+214
+00:15:53,000 --> 00:16:01,000
+and test without exception also has been passed because it was executed without any exception.
+
+215
+00:16:02,000 --> 00:16:06,000
+I recommend you to look through the source code that I left in attachments to the lesson.
+
+216
+00:16:06,000 --> 00:16:11,000
+Run it on your local computer to understand better how it works.
+
+217
+00:16:12,000 --> 00:16:16,000
+And the last thing for the desert I'd like to share with you is repeatable annotations.
+
+218
+00:16:17,000 --> 00:16:23,000
+To be honest, in my opinion, this is a very rare case because in case you need to pass multiple values,
+
+219
+00:16:24,000 --> 00:16:30,000
+you always can define additional elements in the original annotation or declare array of values for
+
+220
+00:16:30,000 --> 00:16:31,000
+some element.
+
+221
+00:16:32,000 --> 00:16:39,000
+Anyway, it was hard for me to come up with real life example in this case, but I just want to demonstrate
+
+222
+00:16:39,000 --> 00:16:42,000
+use a feature that was added in Java version eight.
+
+223
+00:16:42,000 --> 00:16:44,000
+Let me open our demo example.
+
+224
+00:16:45,000 --> 00:16:48,000
+Can they see that I have Orser annotation here duplicated?
+
+225
+00:16:49,000 --> 00:16:56,000
+Normally it is not accepted, and to be able to use the same annotation twice for the same element,
+
+226
+00:16:56,000 --> 00:16:59,000
+you need to perform additional actions.
+
+227
+00:17:00,000 --> 00:17:07,000
+The first thing to do is to add annotation, repeatable annotation definition, like I did for Orser
+
+228
+00:17:07,000 --> 00:17:08,000
+annotation.
+
+229
+00:17:08,000 --> 00:17:15,000
+The second thing to do is to create container for repeatable annotations for compatibility reasons.
+
+230
+00:17:15,000 --> 00:17:19,000
+Repeating annotations are stored in a container annotation.
+
+231
+00:17:20,000 --> 00:17:25,000
+In order for the compiler to do this, two declarations are required in your code.
+
+232
+00:17:25,000 --> 00:17:30,000
+That's why another annotation that we need to create is here.
+
+233
+00:17:30,000 --> 00:17:39,000
+I call it Auster's container annotation must have element value that returns array with objects of repeatable
+
+234
+00:17:39,000 --> 00:17:42,000
+annotation type that we want to repeat.
+
+235
+00:17:42,000 --> 00:17:47,000
+In this case, value element will contain array of Orser annotations.
+
+236
+00:17:47,000 --> 00:17:48,000
+Is that clear?
+
+237
+00:17:49,000 --> 00:17:52,000
+Basically, that's all what I wanted to share with you.
+
+238
+00:17:53,000 --> 00:17:55,000
+Let's review what we have learned in this lesson.
+
+239
+00:17:56,000 --> 00:18:03,000
+In this lesson, we have learned what annotation is also explained to you, why we might need an addition
+
+240
+00:18:03,000 --> 00:18:05,000
+and when we can use it.
+
+241
+00:18:05,000 --> 00:18:08,000
+Now, you know where annotations may be applied.
+
+242
+00:18:09,000 --> 00:18:13,000
+You know why we need targeted annotation and you know what element type in them is.
+
+243
+00:18:14,000 --> 00:18:19,000
+Also, you learned what retention annotation is and what retention policy in them is.
+
+244
+00:18:20,000 --> 00:18:21,000
+In the lesson.
+
+245
+00:18:21,000 --> 00:18:27,000
+We created our custom annotation, and at the end of the lesson, I explained to you how to create repeatable
+
+246
+00:18:27,000 --> 00:18:28,000
+annotations.
+
+247
+00:18:29,000 --> 00:18:32,000
+Basically, that's a summary of all what we have learned today.
+
+248
+00:18:32,000 --> 00:18:37,000
+I have a homework for you in order you can practice in creation of annotations.
+
+249
+00:18:37,000 --> 00:18:41,000
+You also can find a link to the whole in attachment to the lesson.
+
+250
+00:18:41,000 --> 00:18:44,000
+Let's understand what you need to do in this task.
+
+251
+00:18:45,000 --> 00:18:49,000
+You need to create to do annotation that will allow us to track the progress of note.
+
+252
+00:18:49,000 --> 00:18:50,000
+Implement that message.
+
+253
+00:18:51,000 --> 00:18:57,000
+To do annotation has different elements such as author, priority and stages.
+
+254
+00:18:57,000 --> 00:19:05,000
+Some of them have default values and also Element doesn't have annotation can be applied only to masses
+
+255
+00:19:05,000 --> 00:19:07,000
+and should be available under on that.
+
+256
+00:19:07,000 --> 00:19:14,000
+We'll see to create separate classes at the school to do analyzer in that class, we should have massive
+
+257
+00:19:14,000 --> 00:19:22,000
+three chance string value that is generated to do report pay attention that in order your homework would
+
+258
+00:19:22,000 --> 00:19:23,000
+be considered to be done.
+
+259
+00:19:24,000 --> 00:19:28,000
+You need to follow specific partners for each method analysis.
+
+260
+00:19:28,000 --> 00:19:30,000
+One is described here.
+
+261
+00:19:30,000 --> 00:19:35,000
+You should specify method name or search priority on stages.
+
+262
+00:19:35,000 --> 00:19:42,000
+Is it clear any way you will be able to find my solution also in attachments does assessment, but try
+
+263
+00:19:42,000 --> 00:19:49,000
+to solve this task without any help and by yourself first and only in case solution is not on this for
+
+264
+00:19:49,000 --> 00:19:49,000
+you.
+
+265
+00:19:49,000 --> 00:19:56,000
+Use my solution as a reference and as always, in case you have any questions, feel free to add your
+
+266
+00:19:56,000 --> 00:19:58,000
+questions in comments on this video.
+
+267
+00:19:59,000 --> 00:20:01,000
+Thanks a lot you for your attention.
+
+268
+00:20:01,000 --> 00:20:04,000
+Have a great day and see in the next lesson.
+

30 - Java Reflection API/002 Homework-Solution.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/annotations/hw

30 - Java Reflection API/002 Homework.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://docs.google.com/document/d/1SFPh7rGW3vyQnOdSLgMg4v-WE_CTEpgVYyWXJkwfCic/edit?usp=sharing

30 - Java Reflection API/002 Source-code-of-examples-from-the-lesson.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/annotations

30 - Java Reflection API/external-links.txt

@@ -0,0 +1,12 @@
+
+001 Source-code-of-example-from-the-lesson
+https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/reflection/Demo.java
+
+002 Source-code-of-examples-from-the-lesson
+https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/annotations
+
+002 Homework
+https://docs.google.com/document/d/1SFPh7rGW3vyQnOdSLgMg4v-WE_CTEpgVYyWXJkwfCic/edit?usp=sharing
+
+002 Homework-Solution
+https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/annotations/hw

31 - JDK API/001 Source-code-from-the-lesson.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/string/stringbuilder

31 - JDK API/001 StringBuilder & StringBuffer_en.srt

@@ -0,0 +1,760 @@
+1
+00:00:05,000 --> 00:00:06,000
+Hello, Jim.
+
+2
+00:00:06,000 --> 00:00:10,000
+In this lesson, we are going to learn how to work with swing builder and string buffer classes.
+
+3
+00:00:11,000 --> 00:00:14,000
+Also, I'm going to explain why we might need them.
+
+4
+00:00:14,000 --> 00:00:21,000
+We're going to start from understanding what these classes are and why do we need them and want to understand
+
+5
+00:00:21,000 --> 00:00:23,000
+the problems that these classes are supposed to solve.
+
+6
+00:00:24,000 --> 00:00:29,000
+We're going to have practical example where I will explain in detail why you should never forget about
+
+7
+00:00:29,000 --> 00:00:33,000
+string builder and string the buffer in this lesson.
+
+8
+00:00:33,000 --> 00:00:38,000
+I'm going to explain the difference between these two classes and what is even more important.
+
+9
+00:00:38,000 --> 00:00:42,000
+I will teach you when to use these classes and how to use them.
+
+10
+00:00:42,000 --> 00:00:50,000
+I will show you example of string builder and string the bar for usage and also will char sequence interface.
+
+11
+00:00:50,000 --> 00:00:57,000
+Let's start let's try to understand first what a string builder class in the documentation.
+
+12
+00:00:57,000 --> 00:01:02,000
+This class is described as mutable sequence of characters by this moment.
+
+13
+00:01:02,000 --> 00:01:07,000
+Now, of course, you already know that objects of string class are immutable.
+
+14
+00:01:07,000 --> 00:01:13,000
+In short, there's a class designed in the way that you can't change the state of a regional object
+
+15
+00:01:13,000 --> 00:01:15,000
+after it was instantiated.
+
+16
+00:01:16,000 --> 00:01:21,000
+All assets don't modify state of the original string or objects that we created.
+
+17
+00:01:22,000 --> 00:01:28,000
+The class itself is final and you can't override it to change the logic of methods.
+
+18
+00:01:28,000 --> 00:01:35,000
+That means that each time you modify string in your program, you actually create a new object of the
+
+19
+00:01:35,000 --> 00:01:35,000
+string.
+
+20
+00:01:36,000 --> 00:01:42,000
+Yes, you might lose the reference to the string object in case new string object is assigned to the
+
+21
+00:01:42,000 --> 00:01:43,000
+regional variable.
+
+22
+00:01:43,000 --> 00:01:49,000
+And yes, in the case there is no strong references to the object, garbage collector will clean it
+
+23
+00:01:49,000 --> 00:01:49,000
+up.
+
+24
+00:01:50,000 --> 00:01:53,000
+I'm going to show this case in the example later today.
+
+25
+00:01:53,000 --> 00:01:57,000
+But the only question that I want to ask you sounds like this.
+
+26
+00:01:58,000 --> 00:02:02,000
+Do we need to rely on garbage collector and make it work?
+
+27
+00:02:02,000 --> 00:02:07,000
+The answer is no one garbage collector starts its work.
+
+28
+00:02:07,000 --> 00:02:12,000
+It is also some computation time that potentially might be used by US operations.
+
+29
+00:02:12,000 --> 00:02:16,000
+Instead of cleaning up objects without strong references.
+
+30
+00:02:16,000 --> 00:02:22,000
+And by the way, it is important for you to know and remember the difference between different types
+
+31
+00:02:22,000 --> 00:02:23,000
+of references.
+
+32
+00:02:23,000 --> 00:02:29,000
+In case you want to learn more about this topic, make sure you watched my lesson about references where
+
+33
+00:02:29,000 --> 00:02:36,000
+I explained different types of references, but still how to solve a problem of constant creation of
+
+34
+00:02:36,000 --> 00:02:37,000
+string object.
+
+35
+00:02:37,000 --> 00:02:44,000
+If I'm modifying string so the situation might be completely different is a process a lot of strings
+
+36
+00:02:44,000 --> 00:02:50,000
+and you need all of them in one string or you prepare string before writing it to the file.
+
+37
+00:02:51,000 --> 00:02:52,000
+It doesn't matter.
+
+38
+00:02:52,000 --> 00:02:59,000
+But in some hypothetical case, instead of creation, millions of string objects and heap memory, it
+
+39
+00:02:59,000 --> 00:03:04,000
+is recommended to create one object of string, build it up and use it.
+
+40
+00:03:04,000 --> 00:03:09,000
+Does it make sense to understand the motivation of using an object of this type?
+
+41
+00:03:10,000 --> 00:03:10,000
+Great.
+
+42
+00:03:11,000 --> 00:03:14,000
+Let's now understand what a string buffer class is.
+
+43
+00:03:14,000 --> 00:03:21,000
+It would be easy to explain what is this class about because it is almost the same as string builder
+
+44
+00:03:21,000 --> 00:03:21,000
+class.
+
+45
+00:03:22,000 --> 00:03:24,000
+They have similar methods, similar constructors.
+
+46
+00:03:25,000 --> 00:03:27,000
+Literally almost everything is similar.
+
+47
+00:03:27,000 --> 00:03:35,000
+The only difference is that string, the buffer is a safe class and objects of this type might be used
+
+48
+00:03:35,000 --> 00:03:39,000
+in an execution without impact on data consistency.
+
+49
+00:03:39,000 --> 00:03:43,000
+What a lot of training is discussed in the separate section of the course.
+
+50
+00:03:44,000 --> 00:03:51,000
+But still, I would like to remind to all students about multithreaded one more time in in case of Perou
+
+51
+00:03:51,000 --> 00:03:53,000
+execution of multiple threads.
+
+52
+00:03:54,000 --> 00:04:00,000
+When different threads update the state of the string buffer simultaneously or read its data, only
+
+53
+00:04:00,000 --> 00:04:07,000
+one thread is allowed to execute these operations with potential mistakes that may happen because of
+
+54
+00:04:08,000 --> 00:04:09,000
+an axis.
+
+55
+00:04:09,000 --> 00:04:15,000
+That's why everything what I'm going to share with you about String Builder is absolutely applicable
+
+56
+00:04:15,000 --> 00:04:17,000
+to the string buffer in Montessori environment.
+
+57
+00:04:18,000 --> 00:04:24,000
+The rule of thumb is to use three builder whenever is possible because it has better performance.
+
+58
+00:04:25,000 --> 00:04:31,000
+This is just consequences of not having synchronization from multiple threads inside string builder,
+
+59
+00:04:31,000 --> 00:04:38,000
+whereas all mascot's in string buffer are synchronized and this takes additional overhead during the
+
+60
+00:04:38,000 --> 00:04:39,000
+execution.
+
+61
+00:04:39,000 --> 00:04:41,000
+You should be all right with String Builder.
+
+62
+00:04:41,000 --> 00:04:47,000
+In most cases, I believe that you already understood on the high level why we need these classes.
+
+63
+00:04:47,000 --> 00:04:53,000
+It is time to dive deeper in details and understand how to work with objects of this type.
+
+64
+00:04:54,000 --> 00:04:57,000
+And let's start from explaining the hypothetical problem.
+
+65
+00:04:58,000 --> 00:04:59,000
+I have file with stacks.
+
+66
+00:05:00,000 --> 00:05:03,000
+This is lyrics of the song that I listened while.
+
+67
+00:05:03,000 --> 00:05:09,000
+Thinking about the structure of the lesson, the song is called Never Coming Home By Staying Pretty
+
+68
+00:05:10,000 --> 00:05:11,000
+Cool one, by the way.
+
+69
+00:05:11,000 --> 00:05:18,000
+And according to business logic, I need to be able to read text from files and after that work with
+
+70
+00:05:18,000 --> 00:05:20,000
+the content of the file as a whole.
+
+71
+00:05:20,000 --> 00:05:24,000
+For example, text analysis or text statistics is needed.
+
+72
+00:05:25,000 --> 00:05:29,000
+Probably you want to implement programs that would analyze thousands of songs in order.
+
+73
+00:05:29,000 --> 00:05:36,000
+You could find the best rhymes any way you can be in any of other situations that would make it to collect
+
+74
+00:05:36,000 --> 00:05:39,000
+all streams in one string object.
+
+75
+00:05:39,000 --> 00:05:47,000
+I open my example now that is called string build a demo I have mastered that reads all lines from file
+
+76
+00:05:47,000 --> 00:05:52,000
+into one string object and after that I bring the strings to console.
+
+77
+00:05:52,000 --> 00:05:54,000
+Let's review this method.
+
+78
+00:05:54,000 --> 00:06:00,000
+I create the reference of the same time as it is pointing out to the object that is stored in St. Paul.
+
+79
+00:06:01,000 --> 00:06:07,000
+If you don't remember what a string will please refer to as a lesson about string objects and string
+
+80
+00:06:07,000 --> 00:06:09,000
+CPU in my Java course.
+
+81
+00:06:09,000 --> 00:06:14,000
+In the next line I read all lines from file into the list of strings.
+
+82
+00:06:14,000 --> 00:06:20,000
+In case you're interested how I did this, please refer to the section about input output streams in
+
+83
+00:06:20,000 --> 00:06:21,000
+my Java course.
+
+84
+00:06:21,000 --> 00:06:29,000
+After that I iterate and over each line and I concatenate each line with my result string and adding
+
+85
+00:06:29,000 --> 00:06:31,000
+new one character at the end of each line.
+
+86
+00:06:32,000 --> 00:06:34,000
+What is actually happening here?
+
+87
+00:06:34,000 --> 00:06:41,000
+I create a new string object after each concatenation and this string reference pointing out to the
+
+88
+00:06:41,000 --> 00:06:42,000
+new object in memory.
+
+89
+00:06:42,000 --> 00:06:48,000
+Each time after concatenation you are going to have the object that contains the first line.
+
+90
+00:06:48,000 --> 00:06:52,000
+Only the second object would be the first line.
+
+91
+00:06:52,000 --> 00:06:59,000
+And Newline character is a shared object, would be the first line newline character and the second
+
+92
+00:06:59,000 --> 00:07:00,000
+line and so on.
+
+93
+00:07:01,000 --> 00:07:05,000
+Why do you need so many duplication and so many string objects?
+
+94
+00:07:05,000 --> 00:07:09,000
+And that is not a big harm in process in one song.
+
+95
+00:07:09,000 --> 00:07:15,000
+But believe me, you are going to work with files much bigger than we have in our example today.
+
+96
+00:07:15,000 --> 00:07:17,000
+And this is going to become a problem.
+
+97
+00:07:18,000 --> 00:07:19,000
+What would be the solution here?
+
+98
+00:07:19,000 --> 00:07:22,000
+The solution here is to use string build object.
+
+99
+00:07:23,000 --> 00:07:29,000
+Let's look at another method that also read all lines from the file, but do it with help of string
+
+100
+00:07:29,000 --> 00:07:30,000
+builder object.
+
+101
+00:07:30,000 --> 00:07:34,000
+I create object of string, build a type with the default constructor.
+
+102
+00:07:35,000 --> 00:07:37,000
+After that I am doing the same thing.
+
+103
+00:07:37,000 --> 00:07:39,000
+I'm bringing the lines into the list.
+
+104
+00:07:39,000 --> 00:07:41,000
+Object in foreach loop.
+
+105
+00:07:41,000 --> 00:07:45,000
+I call append massata patterns new line and newline character.
+
+106
+00:07:46,000 --> 00:07:51,000
+I need to return a string object from the method so I call to string methods.
+
+107
+00:07:51,000 --> 00:07:54,000
+It creates string object based on my string builder.
+
+108
+00:07:55,000 --> 00:07:55,000
+That's it.
+
+109
+00:07:56,000 --> 00:08:02,000
+To prove you that concatenation of strings with string builder is more efficient, I evaluate the time
+
+110
+00:08:02,000 --> 00:08:04,000
+for both of these separations.
+
+111
+00:08:04,000 --> 00:08:11,000
+I just take amount of milliseconds before the first method invocation and after that I calculate Delta
+
+112
+00:08:11,000 --> 00:08:19,000
+in milliseconds by the doctors the time that I already have from current time after method execution.
+
+113
+00:08:19,000 --> 00:08:24,000
+Following this approach, I can estimate how long does it take to execute code?
+
+114
+00:08:24,000 --> 00:08:26,000
+That is between two points.
+
+115
+00:08:26,000 --> 00:08:30,000
+And I did similar measurement in the second example for String Builder.
+
+116
+00:08:31,000 --> 00:08:37,000
+After that I bring two values to console in order we could have a chance to compare these two values.
+
+117
+00:08:37,000 --> 00:08:45,000
+Let's run the program so you can see the difference in performance with one song of string is approximately
+
+118
+00:08:45,000 --> 00:08:47,000
+ten times more restrained.
+
+119
+00:08:47,000 --> 00:08:49,000
+Object concatenation.
+
+120
+00:08:49,000 --> 00:08:52,000
+Imagine what the difference would be was a gigabyte files.
+
+121
+00:08:53,000 --> 00:08:54,000
+It is crazy.
+
+122
+00:08:54,000 --> 00:08:59,000
+That's why it is important to use string builder during the processing of big number of strings.
+
+123
+00:09:00,000 --> 00:09:06,000
+Basically, we have just removed probably the most popular example of string builder and string bar
+
+124
+00:09:06,000 --> 00:09:07,000
+for usage.
+
+125
+00:09:07,000 --> 00:09:12,000
+But let me also share with you a little bit more details about class structure and other methods.
+
+126
+00:09:13,000 --> 00:09:15,000
+I open the source code of string builder class.
+
+127
+00:09:16,000 --> 00:09:21,000
+And just to remind you, what we are going to review now is absolutely similar in string.
+
+128
+00:09:21,000 --> 00:09:23,000
+The buffer clause was only one exception.
+
+129
+00:09:23,000 --> 00:09:25,000
+Synchronized methods.
+
+130
+00:09:25,000 --> 00:09:28,000
+This is the full constructor calls, constructor of super class.
+
+131
+00:09:29,000 --> 00:09:35,000
+That is abstract string the builder specifying the original capacity of the characters array.
+
+132
+00:09:35,000 --> 00:09:37,000
+By default it is 610.
+
+133
+00:09:38,000 --> 00:09:41,000
+Do not find any Secrett logic behind this number.
+
+134
+00:09:41,000 --> 00:09:42,000
+It is just 16.
+
+135
+00:09:43,000 --> 00:09:48,000
+There is also a string builder within parameter to specify any custom default capacity.
+
+136
+00:09:49,000 --> 00:09:51,000
+One you should use this version of constructor.
+
+137
+00:09:52,000 --> 00:09:55,000
+I believe that you already know how arrays work in Java.
+
+138
+00:09:55,000 --> 00:09:59,000
+You can text extend array that was created already.
+
+139
+00:10:00,000 --> 00:10:02,000
+So to extent existing array you need.
+
+140
+00:10:03,000 --> 00:10:09,000
+To create a bigger array and copy old values in that this is time consuming operation.
+
+141
+00:10:10,000 --> 00:10:16,000
+That's why in case you know that you're going to process a big amount of data, you can set initial
+
+142
+00:10:16,000 --> 00:10:23,000
+capacity in order to avoid concentration of new array objects, to have enough space for all characters.
+
+143
+00:10:23,000 --> 00:10:30,000
+Also, we can create string builder and initialize it with the content of the string object or any char
+
+144
+00:10:30,000 --> 00:10:30,000
+sequence.
+
+145
+00:10:31,000 --> 00:10:37,000
+Short sequence is an interface that is implemented by many different classes in Java, for example,
+
+146
+00:10:37,000 --> 00:10:42,000
+string swing builder, string buffer, abstract string builder and others.
+
+147
+00:10:42,000 --> 00:10:45,000
+All of them implements char sequence interface.
+
+148
+00:10:46,000 --> 00:10:53,000
+This interface declares contract for such mascot's as Lancs to return total number of characters in
+
+149
+00:10:53,000 --> 00:11:01,000
+char sequence char at Richmondshire as a specified index is empty default masset the checks with the
+
+150
+00:11:01,000 --> 00:11:03,000
+Lancs equal to zero returns.
+
+151
+00:11:03,000 --> 00:11:10,000
+True, if character sequence is empty and false, otherwise Subsequence Masset will return char sequence
+
+152
+00:11:10,000 --> 00:11:14,000
+from indexing collusively to indexed exclusively.
+
+153
+00:11:14,000 --> 00:11:16,000
+And you know what the string method does.
+
+154
+00:11:17,000 --> 00:11:22,000
+Also, we are a few more default methods and one Zem Chass returns in stream.
+
+155
+00:11:23,000 --> 00:11:31,000
+Just to remind you that Char easily may be converted to end Y because integer variable specifies sequence
+
+156
+00:11:31,000 --> 00:11:40,000
+number of the character and the Unicode table code points returns in stream where each end will represent
+
+157
+00:11:40,000 --> 00:11:42,000
+characters sequence number in the Unicode table.
+
+158
+00:11:43,000 --> 00:11:49,000
+I will be honest with you, I have never used this method, but at least it is good just to know that
+
+159
+00:11:49,000 --> 00:11:56,000
+such as it exists in learning purposes and static methods that may be used to combat two character sequences.
+
+160
+00:11:57,000 --> 00:12:02,000
+Let's get back to the implementation of a sequence that we are running today.
+
+161
+00:12:02,000 --> 00:12:04,000
+I open string builder class.
+
+162
+00:12:04,000 --> 00:12:10,000
+As you can see in outline here, there are a lot of versions of append method.
+
+163
+00:12:11,000 --> 00:12:16,000
+This method is overloaded to be able to accept parameter of different types.
+
+164
+00:12:16,000 --> 00:12:23,000
+Also, we can delete from char to char, from string builder onto the teacher at the specified index.
+
+165
+00:12:23,000 --> 00:12:28,000
+And again, it is hard for me to come up with an example where you would use this massas on a daily
+
+166
+00:12:28,000 --> 00:12:35,000
+basis, replace Masset from index to index and be replaced with the string.
+
+167
+00:12:36,000 --> 00:12:39,000
+Another method that is overloaded in this class is insert.
+
+168
+00:12:40,000 --> 00:12:44,000
+It is used to insert the specified value at the specified position.
+
+169
+00:12:44,000 --> 00:12:45,000
+It is overloaded.
+
+170
+00:12:45,000 --> 00:12:53,000
+The Different Parameters Index of Masset returns the index within this string of the first occurrence
+
+171
+00:12:53,000 --> 00:12:58,000
+of the specified substring last index of returns.
+
+172
+00:12:58,000 --> 00:13:03,000
+The index within this string of the last occurrence of the specified substring.
+
+173
+00:13:03,000 --> 00:13:10,000
+The last two methods also have overloaded version that additionally it takes one more parameter of time.
+
+174
+00:13:11,000 --> 00:13:15,000
+This is the index from which to start the search reverse.
+
+175
+00:13:15,000 --> 00:13:21,000
+Massata causes this character sequence to be replaced by the reverse of the sequence.
+
+176
+00:13:21,000 --> 00:13:24,000
+That's all methods of string builder class.
+
+177
+00:13:24,000 --> 00:13:30,000
+What I would recommend you open the source code of string builder string, buffer and abstract string
+
+178
+00:13:30,000 --> 00:13:36,000
+to build the class leukocoria through the code and try to play with matches.
+
+179
+00:13:36,000 --> 00:13:41,000
+We have discussed the most important ones and the masses that have chance to be used in production.
+
+180
+00:13:42,000 --> 00:13:48,000
+But in case you would find any other method that you are interested in and you would like to talk more
+
+181
+00:13:48,000 --> 00:13:51,000
+about it, do not hesitate to ask questions below this video.
+
+182
+00:13:51,000 --> 00:13:57,000
+I will be happy to answer all of your questions, but I truly believe that we have learned just enough
+
+183
+00:13:57,000 --> 00:14:02,000
+things in order to be able to start using string builder and string four classes.
+
+184
+00:14:03,000 --> 00:14:06,000
+Now, let's recap what we have learned in this lesson.
+
+185
+00:14:06,000 --> 00:14:10,000
+After this lesson, we know what string builder and string buffer classes are.
+
+186
+00:14:11,000 --> 00:14:17,000
+I believe that you understood the purpose of these classes and use cases when to use them.
+
+187
+00:14:17,000 --> 00:14:20,000
+Also review the char sequence interface today.
+
+188
+00:14:20,000 --> 00:14:22,000
+That's it for this lesson.
+
+189
+00:14:22,000 --> 00:14:24,000
+Thanks a lot for your attention.
+
+190
+00:14:24,000 --> 00:14:27,000
+Have a great day and see you in the next lesson.
+

31 - JDK API/002 Source-code-examples-from-the-lesson.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/optional

31 - JDK API/002 java.util.Optional - Optional in Java_en.srt

@@ -0,0 +1,1476 @@
+1
+00:00:06,000 --> 00:00:06,000
+Hello, Jim.
+
+2
+00:00:06,000 --> 00:00:09,000
+In this lesson, we're going to learn optional class API.
+
+3
+00:00:10,000 --> 00:00:16,000
+We're going to start a lesson from the definition of optional class is understanding of the goal and
+
+4
+00:00:16,000 --> 00:00:24,000
+purpose of this class will help you to understand that better known this will be an optional class API.
+
+5
+00:00:24,000 --> 00:00:31,000
+And on real Covid examples I'm going to show you how to work was methods from optional class, and then
+
+6
+00:00:31,000 --> 00:00:33,000
+to the lesson of explaining when to use optional.
+
+7
+00:00:33,000 --> 00:00:40,000
+And you will understand in which cases use of optional will be efficient and will not bring more harm
+
+8
+00:00:40,000 --> 00:00:41,000
+than good.
+
+9
+00:00:41,000 --> 00:00:48,000
+Besides that, I will answer to the question what alternative techniques might be used instead of optional?
+
+10
+00:00:48,000 --> 00:00:49,000
+Let's stop.
+
+11
+00:00:50,000 --> 00:00:53,000
+And let me start from explanation of what optional class is.
+
+12
+00:00:53,000 --> 00:00:54,000
+And why do we need it?
+
+13
+00:00:55,000 --> 00:00:56,000
+Do you know what?
+
+14
+00:00:56,000 --> 00:00:58,000
+No point or exception is?
+
+15
+00:00:58,000 --> 00:00:59,000
+Probably.
+
+16
+00:00:59,000 --> 00:01:04,000
+This is one of the most popular exceptions that interrupts our program execution.
+
+17
+00:01:04,000 --> 00:01:09,000
+Just a reminder to all students that no point or exception is an exception.
+
+18
+00:01:09,000 --> 00:01:10,000
+That's a strong one.
+
+19
+00:01:10,000 --> 00:01:13,000
+We try to invoke some Masset on the reference.
+
+20
+00:01:13,000 --> 00:01:15,000
+It is not initialized.
+
+21
+00:01:15,000 --> 00:01:17,000
+In other words, we have variables.
+
+22
+00:01:17,000 --> 00:01:21,000
+It doesn't store reference to any of objects in the heap memory.
+
+23
+00:01:22,000 --> 00:01:26,000
+And when we call some Massart on the variable, we received no pointer exception.
+
+24
+00:01:26,000 --> 00:01:32,000
+That tells us that we actually can't invoke any Massart on the nothing.
+
+25
+00:01:32,000 --> 00:01:33,000
+Is that clear?
+
+26
+00:01:33,000 --> 00:01:40,000
+And to avoid cases like this, we should never forget to perform no check before any Massart invocation.
+
+27
+00:01:41,000 --> 00:01:47,000
+The new clause that has been introduced in Java eight is supposed to alleviate some problems.
+
+28
+00:01:47,000 --> 00:01:53,000
+In my opinion, the introduction of this class is controversial from one side.
+
+29
+00:01:53,000 --> 00:02:00,000
+It is grades that geoengineers has two legs, this one to indicate places where we may have no potentially.
+
+30
+00:02:00,000 --> 00:02:07,000
+But from the other side, in my opinion, optional class, often used by developers inappropriately
+
+31
+00:02:07,000 --> 00:02:11,000
+and brings into the code more complexity and harm than good.
+
+32
+00:02:11,000 --> 00:02:16,000
+But in this lesson, I will share with you my tips and other you use optional class efficiently.
+
+33
+00:02:17,000 --> 00:02:23,000
+Generally speaking written and no reference from any massata considered to be a bad practice.
+
+34
+00:02:23,000 --> 00:02:30,000
+For example, you call getta on the object that doesn't have all fields initialized yet, and you receive
+
+35
+00:02:30,000 --> 00:02:31,000
+no reference.
+
+36
+00:02:31,000 --> 00:02:32,000
+Indeed.
+
+37
+00:02:32,000 --> 00:02:35,000
+What else you should receive if there is nothing yet?
+
+38
+00:02:36,000 --> 00:02:41,000
+What if a field is really empty and doesn't initialized with any reference yet?
+
+39
+00:02:41,000 --> 00:02:42,000
+Thorney ha.
+
+40
+00:02:43,000 --> 00:02:48,000
+One of the giants of computer science wrote I call it my billion dollar mistake.
+
+41
+00:02:49,000 --> 00:02:53,000
+It was the invention of the no reference in nineteen sixty five.
+
+42
+00:02:53,000 --> 00:03:00,000
+I couldn't resist the temptation to put in a no reference simply because it was so easy to implement.
+
+43
+00:03:01,000 --> 00:03:05,000
+I can add to that it wasn't just so easy to implement.
+
+44
+00:03:05,000 --> 00:03:08,000
+It was also so logical to implement.
+
+45
+00:03:09,000 --> 00:03:13,000
+Let me start sharing my screen to explain the problems that we have today.
+
+46
+00:03:13,000 --> 00:03:14,000
+Is it optional?
+
+47
+00:03:14,000 --> 00:03:21,000
+Closs is intended to solve I open class problem statement from optional package of my little project.
+
+48
+00:03:21,000 --> 00:03:24,000
+In this example, imagine that we have instance of the computer.
+
+49
+00:03:25,000 --> 00:03:32,000
+We have some computer and USB drive, potentially USB drive, maybe plugged in or may not.
+
+50
+00:03:33,000 --> 00:03:40,000
+I can call yet USB drive Massart on my computer object to get the reference to the USB drive in case
+
+51
+00:03:40,000 --> 00:03:42,000
+Nassan is plugged in.
+
+52
+00:03:42,000 --> 00:03:44,000
+I receive no correct.
+
+53
+00:03:44,000 --> 00:03:51,000
+But in case there is a USB drive, I can get access to the right contacts switch to check it state.
+
+54
+00:03:52,000 --> 00:03:55,000
+In this case, I need to perform no check again.
+
+55
+00:03:55,000 --> 00:03:57,000
+Can you see how my code looks like?
+
+56
+00:03:58,000 --> 00:04:03,000
+And the good thing about all this is that I am smart enough to perform such checks.
+
+57
+00:04:03,000 --> 00:04:07,000
+It would be worse in case such checks wouldn't exist at all.
+
+58
+00:04:08,000 --> 00:04:10,000
+And to my program would just fail.
+
+59
+00:04:10,000 --> 00:04:17,000
+Units execution that understands the point, in addition, is just annoying that these checks get in
+
+60
+00:04:17,000 --> 00:04:19,000
+the way of the business logic.
+
+61
+00:04:20,000 --> 00:04:24,000
+In fact, Zedek reasons that overall are the beauty of our program.
+
+62
+00:04:25,000 --> 00:04:27,000
+What would be better than this?
+
+63
+00:04:27,000 --> 00:04:33,000
+It will be better to build data structure that would indicate presence or absence of the value.
+
+64
+00:04:34,000 --> 00:04:35,000
+That's what we need.
+
+65
+00:04:35,000 --> 00:04:36,000
+Optional Class four.
+
+66
+00:04:37,000 --> 00:04:44,000
+So we agreed that we need a mechanism that allows a massive developer to explicitly denote there's a
+
+67
+00:04:44,000 --> 00:04:51,000
+return value for a massive may or may not be present optional class acts as a prop for an object that
+
+68
+00:04:51,000 --> 00:04:53,000
+may not be present.
+
+69
+00:04:53,000 --> 00:04:59,000
+Therefore, if we know that our get USB drive mass, it may not return a desert object.
+
+70
+00:05:00,000 --> 00:05:02,000
+We can change message, return type.
+
+71
+00:05:02,000 --> 00:05:10,000
+Let me open solution class now in this class, you can see is that get USB drive message from my computer
+
+72
+00:05:10,000 --> 00:05:12,000
+class, has the friends or Chen typed now?
+
+73
+00:05:13,000 --> 00:05:16,000
+It is optional parametrized by the USB drive.
+
+74
+00:05:17,000 --> 00:05:18,000
+And then my USB drive.
+
+75
+00:05:18,000 --> 00:05:20,000
+I have also updated through Chintan.
+
+76
+00:05:21,000 --> 00:05:28,000
+Now, is this is optional that this parametrized by rights protects, which did not pay a lot of attention
+
+77
+00:05:28,000 --> 00:05:35,000
+to the details at this moment, namely how we create objects of optional type, why I use this method
+
+78
+00:05:35,000 --> 00:05:36,000
+and didn't use another one.
+
+79
+00:05:36,000 --> 00:05:41,000
+We're going to learn optional gloss in a minute was detailed examples.
+
+80
+00:05:41,000 --> 00:05:46,000
+Now, I'd like you to understand the idea of problem and our solution.
+
+81
+00:05:46,000 --> 00:05:53,000
+In my main mass, you can see that I use features of optional class and they check whether some value
+
+82
+00:05:53,000 --> 00:05:55,000
+is present in my USB drive wrapper.
+
+83
+00:05:56,000 --> 00:06:01,000
+And this present I execute functions that takes USB drive as my argument.
+
+84
+00:06:02,000 --> 00:06:06,000
+Namely, I'm getting access to the switch, which is also optional.
+
+85
+00:06:06,000 --> 00:06:11,000
+And in case it is present, I just print switches state to console.
+
+86
+00:06:12,000 --> 00:06:14,000
+And if no, then nothing.
+
+87
+00:06:14,000 --> 00:06:20,000
+And in case there is no USB drive object inside the wrapper, I execute another function.
+
+88
+00:06:20,000 --> 00:06:22,000
+I just print to console.
+
+89
+00:06:22,000 --> 00:06:24,000
+That USB drive wasn't found.
+
+90
+00:06:24,000 --> 00:06:30,000
+As you can see on this example, optional is a similar to the wrapper that may or may not contains the
+
+91
+00:06:30,000 --> 00:06:33,000
+actual value inside itself.
+
+92
+00:06:33,000 --> 00:06:40,000
+In simple words, you can view optional as a single value container that is a contains a value of doesn't.
+
+93
+00:06:41,000 --> 00:06:44,000
+It isn't set to be empty fullerenes.
+
+94
+00:06:44,000 --> 00:06:49,000
+This construction, you make clients responsible to handle messy value.
+
+95
+00:06:49,000 --> 00:06:51,000
+You're just walking.
+
+96
+00:06:51,000 --> 00:06:56,000
+That value here may not be present and you decide what you want to do.
+
+97
+00:06:56,000 --> 00:07:04,000
+In this case, this client's responsible approach means that creators and Massart is not in the position
+
+98
+00:07:04,000 --> 00:07:07,000
+to define what should be done in case of missing value.
+
+99
+00:07:08,000 --> 00:07:12,000
+Is a sink is to throw exception Maseru an exception?
+
+100
+00:07:12,000 --> 00:07:17,000
+Probably not always the best case and proper behavior according to the business logic in the case of
+
+101
+00:07:17,000 --> 00:07:18,000
+missing value.
+
+102
+00:07:19,000 --> 00:07:23,000
+Now, I wonder, you look at this example with fresh eyes.
+
+103
+00:07:23,000 --> 00:07:29,000
+If Java community and software engineers would like to call this more readable code and simple if URL
+
+104
+00:07:29,000 --> 00:07:32,000
+statement, I am happy to accept it.
+
+105
+00:07:32,000 --> 00:07:36,000
+Really, guys, I just want to we don't lie to ourselves.
+
+106
+00:07:36,000 --> 00:07:43,000
+What we have, instead of if as blogs with a few lambda expressions that are also located inside each
+
+107
+00:07:43,000 --> 00:07:43,000
+other.
+
+108
+00:07:43,000 --> 00:07:50,000
+And moreover, all our mass is written optional now, and we can't just take value and work with it
+
+109
+00:07:50,000 --> 00:07:50,000
+in order.
+
+110
+00:07:50,000 --> 00:07:52,000
+We could avoid no point exception.
+
+111
+00:07:52,000 --> 00:07:56,000
+Well, definitely optional is a very powerful tool.
+
+112
+00:07:56,000 --> 00:08:00,000
+But guys, I can't see what we have want in this case.
+
+113
+00:08:01,000 --> 00:08:06,000
+There are multiple other features in optional that breena's amazing flexibility.
+
+114
+00:08:06,000 --> 00:08:11,000
+And let us write less lines of code with optional than without it.
+
+115
+00:08:12,000 --> 00:08:12,000
+That is true.
+
+116
+00:08:13,000 --> 00:08:20,000
+But again, it should be also a special case to apply those features of optional is a true story from
+
+117
+00:08:20,000 --> 00:08:26,000
+my life is one developer from my team created few classes, was all massive rechanneled, optional type
+
+118
+00:08:26,000 --> 00:08:28,000
+parameterized by other types.
+
+119
+00:08:28,000 --> 00:08:31,000
+I asked him, why would you do that?
+
+120
+00:08:31,000 --> 00:08:37,000
+And he replied, because we need to use optional everywhere where we may receive no.
+
+121
+00:08:37,000 --> 00:08:39,000
+Well, guess not everywhere.
+
+122
+00:08:39,000 --> 00:08:41,000
+And then again, use an optional everywhere.
+
+123
+00:08:42,000 --> 00:08:46,000
+Wouldn't agree with us for the better with the abilities that we are so struggling for.
+
+124
+00:08:46,000 --> 00:08:54,000
+So let's not API optional to better understand its power and understand, jaysus, when and where this
+
+125
+00:08:54,000 --> 00:08:54,000
+might be applicable.
+
+126
+00:08:55,000 --> 00:08:59,000
+I open optional demo class with a lot of examples here.
+
+127
+00:08:59,000 --> 00:09:01,000
+Let me walk you through each example.
+
+128
+00:09:01,000 --> 00:09:09,000
+Seeing the first ones that we are going to review is how to create an object of optional type in most
+
+129
+00:09:09,000 --> 00:09:15,000
+of the cases to create object of type optional when it is static, factor in masses, optional class.
+
+130
+00:09:16,000 --> 00:09:19,000
+The first way to create optional is to call static mass of empty.
+
+131
+00:09:20,000 --> 00:09:22,000
+This is our chance imta optional.
+
+132
+00:09:22,000 --> 00:09:28,000
+The empty mass is often used when it is known apro or is at no value exists.
+
+133
+00:09:28,000 --> 00:09:35,000
+If you have some value and you need to create optional call, static method of attention, you need
+
+134
+00:09:35,000 --> 00:09:42,000
+to have that object behind's a reference that you are going to use to create optional object was of
+
+135
+00:09:42,000 --> 00:09:49,000
+mass, because in case you pass no value to the of method, you will get no point exception.
+
+136
+00:09:49,000 --> 00:09:55,000
+In the case, you know its value behind the reference, Megan, now or may not be now, use another
+
+137
+00:09:55,000 --> 00:09:57,000
+method of nullable.
+
+138
+00:09:58,000 --> 00:10:02,000
+This will create optional object based on the no and no not.
+
+139
+00:10:02,000 --> 00:10:09,000
+Various for example, in previous example, in solution, I used of nullable factor in mass because
+
+140
+00:10:09,000 --> 00:10:14,000
+I knew that I may need to create optional object based on value.
+
+141
+00:10:15,000 --> 00:10:22,000
+Now let's review methods that allow us to check if value is present or absent, that the masses that
+
+142
+00:10:22,000 --> 00:10:27,000
+allow us to check the value inside the optional is present and is empty.
+
+143
+00:10:28,000 --> 00:10:31,000
+Obviously, these masses are controversial.
+
+144
+00:10:31,000 --> 00:10:37,000
+One is present, returns true, is empty, returns false, and vice versa.
+
+145
+00:10:37,000 --> 00:10:38,000
+Here's an example.
+
+146
+00:10:38,000 --> 00:10:46,000
+You can see that I have destry quail and check was an optional is empty or has value and is a similar
+
+147
+00:10:46,000 --> 00:10:48,000
+test for optional that contains Nassan.
+
+148
+00:10:49,000 --> 00:10:53,000
+As a result of method execution, you confront and conceal output.
+
+149
+00:10:54,000 --> 00:10:56,000
+Now let's review example of conditional masses.
+
+150
+00:10:57,000 --> 00:11:03,000
+I call these methods conditional because based on the specific condition, API allows us to perform
+
+151
+00:11:03,000 --> 00:11:05,000
+one or another action.
+
+152
+00:11:06,000 --> 00:11:12,000
+The first method in this example, if present you already you saw me using this method in the example
+
+153
+00:11:12,000 --> 00:11:18,000
+in solution was use B drive F presence method takes consumer as method argument.
+
+154
+00:11:19,000 --> 00:11:25,000
+If you're not familiar with lambda expressions and such function interfaces as consumer, I recommend
+
+155
+00:11:25,000 --> 00:11:26,000
+you to pass my course.
+
+156
+00:11:26,000 --> 00:11:29,000
+Guanciale programming for Giwa Engineers.
+
+157
+00:11:29,000 --> 00:11:32,000
+I explained these topics in detail zere.
+
+158
+00:11:32,000 --> 00:11:37,000
+Just to remind you, consumer takes some argument and returns nothing.
+
+159
+00:11:37,000 --> 00:11:41,000
+So basically, if the value is present, we pass it.
+
+160
+00:11:41,000 --> 00:11:44,000
+Does it function and perform any action?
+
+161
+00:11:44,000 --> 00:11:44,000
+Was it.
+
+162
+00:11:44,000 --> 00:11:47,000
+What we need in this particular example.
+
+163
+00:11:47,000 --> 00:11:51,000
+I just printed to console in case there is no value in optional.
+
+164
+00:11:51,000 --> 00:11:55,000
+We just ignore this function and just do nothing.
+
+165
+00:11:55,000 --> 00:11:59,000
+Another conditional Massart is if present or else.
+
+166
+00:11:59,000 --> 00:12:03,000
+I also use this one in solution of the examples that I have already showed.
+
+167
+00:12:03,000 --> 00:12:09,000
+I believe that from the massive name, it is already clear for you what is this method for.
+
+168
+00:12:09,000 --> 00:12:14,000
+So in case value is present, will use consumer and will work with the value.
+
+169
+00:12:15,000 --> 00:12:22,000
+In the case, value is absent, will execute some random that contains lines of code to be executed.
+
+170
+00:12:22,000 --> 00:12:24,000
+In case there is no value.
+
+171
+00:12:24,000 --> 00:12:28,000
+The next example is simple and regular gets massive.
+
+172
+00:12:28,000 --> 00:12:34,000
+You can extract value from optional Bikel and get mass, but be attentive.
+
+173
+00:12:34,000 --> 00:12:38,000
+In case there is no value, you will get no such element.
+
+174
+00:12:38,000 --> 00:12:38,000
+The exception.
+
+175
+00:12:39,000 --> 00:12:43,000
+And here, in example, you can see this just in case optional is empty.
+
+176
+00:12:43,000 --> 00:12:45,000
+We are catching exception.
+
+177
+00:12:45,000 --> 00:12:49,000
+In practice, it is recommended to use is present.
+
+178
+00:12:49,000 --> 00:12:53,000
+Massett, that guarantees that there is a value inside optional.
+
+179
+00:12:53,000 --> 00:12:55,000
+So just remember this.
+
+180
+00:12:56,000 --> 00:12:58,000
+Let's imagine that we are using is present Massart.
+
+181
+00:12:58,000 --> 00:12:59,000
+OK.
+
+182
+00:12:59,000 --> 00:13:01,000
+Just look at this example.
+
+183
+00:13:01,000 --> 00:13:09,000
+How far it is from no check from our problem statement was if we again have the similar Evelio.
+
+184
+00:13:09,000 --> 00:13:16,000
+That's why in most cases we intentionally award to use the get Masset and use one of the other methods.
+
+185
+00:13:16,000 --> 00:13:17,000
+Such as.
+
+186
+00:13:17,000 --> 00:13:23,000
+Or else or else through top things of value associated with a populated, optional.
+
+187
+00:13:24,000 --> 00:13:25,000
+Or perform another action.
+
+188
+00:13:25,000 --> 00:13:30,000
+Let me show you this in the next example, you can see how to use or else mass.
+
+189
+00:13:31,000 --> 00:13:36,000
+Basically, it returns a value if at this present and in case it does not.
+
+190
+00:13:36,000 --> 00:13:39,000
+It returns the values that they passed as a message.
+
+191
+00:13:39,000 --> 00:13:41,000
+Also, we have or else get method.
+
+192
+00:13:42,000 --> 00:13:45,000
+What is the difference between orals and this?
+
+193
+00:13:45,000 --> 00:13:48,000
+Massively different parameters oils.
+
+194
+00:13:48,000 --> 00:13:51,000
+Yet they supply as methods argument.
+
+195
+00:13:51,000 --> 00:13:54,000
+Supply is a function that produce something.
+
+196
+00:13:54,000 --> 00:13:57,000
+It takes nothing and returns some value.
+
+197
+00:13:57,000 --> 00:13:59,000
+And what does it give us?
+
+198
+00:14:00,000 --> 00:14:03,000
+Well, probably it is not obvious in this particular example.
+
+199
+00:14:04,000 --> 00:14:06,000
+But let's look at the next lines.
+
+200
+00:14:07,000 --> 00:14:14,000
+Imagine that you have some massive that performs a lot of work and calculations and as a result, recharges
+
+201
+00:14:14,000 --> 00:14:19,000
+your reference to string value and then use your call or else Massett.
+
+202
+00:14:19,000 --> 00:14:26,000
+And you would like to parse the string returned by these massive PZM Massett is actually involved.
+
+203
+00:14:27,000 --> 00:14:31,000
+And you spent some time to wait until the mass of the got finished.
+
+204
+00:14:32,000 --> 00:14:35,000
+But is it the same with or else get method?
+
+205
+00:14:35,000 --> 00:14:36,000
+No.
+
+206
+00:14:36,000 --> 00:14:45,000
+Lukins this line you're actually not invoking is a massive you just Parsons's reference to the function
+
+207
+00:14:45,000 --> 00:14:48,000
+that knows how to get the value for you.
+
+208
+00:14:48,000 --> 00:14:50,000
+In case this is needed.
+
+209
+00:14:51,000 --> 00:14:52,000
+This is the main difference.
+
+210
+00:14:53,000 --> 00:15:00,000
+Lasing insolate Zeeshan in the first case we're invoking Massart no matter was an optional has a value
+
+211
+00:15:00,000 --> 00:15:00,000
+on.
+
+212
+00:15:00,000 --> 00:15:00,000
+No.
+
+213
+00:15:01,000 --> 00:15:01,000
+And in.
+
+214
+00:15:01,000 --> 00:15:08,000
+The second case would just use functions that knows how to provide us with value only when it is needed,
+
+215
+00:15:09,000 --> 00:15:11,000
+only when optional has no value.
+
+216
+00:15:12,000 --> 00:15:18,000
+Does it make sense now in case the value is absent and you want to throw an exception.
+
+217
+00:15:18,000 --> 00:15:20,000
+You can use or else throw massive.
+
+218
+00:15:21,000 --> 00:15:23,000
+This method is overloaded.
+
+219
+00:15:23,000 --> 00:15:26,000
+The version without arguments will throw no such element.
+
+220
+00:15:26,000 --> 00:15:28,000
+The exception by default.
+
+221
+00:15:28,000 --> 00:15:35,000
+Or you can post supplier as Mussert argument to generate object of the exception that you would like
+
+222
+00:15:35,000 --> 00:15:35,000
+to throw.
+
+223
+00:15:36,000 --> 00:15:38,000
+Now let's somehow filter Massart works.
+
+224
+00:15:39,000 --> 00:15:45,000
+In case you have the reference to the optional object, you can check it first to understand whether
+
+225
+00:15:45,000 --> 00:15:46,000
+it is much your predicate.
+
+226
+00:15:47,000 --> 00:15:52,000
+And in case verification this past, you receive optional was that value.
+
+227
+00:15:52,000 --> 00:15:55,000
+Otherwise, you receive empty optional.
+
+228
+00:15:55,000 --> 00:15:57,000
+Let me explain this example.
+
+229
+00:15:57,000 --> 00:16:01,000
+Imagine that I have optional that contains my full name.
+
+230
+00:16:01,000 --> 00:16:07,000
+After that, I can call Filton Masset on the optional object and pass predicate.
+
+231
+00:16:07,000 --> 00:16:10,000
+Let me quickly remind you what Prickett is.
+
+232
+00:16:11,000 --> 00:16:14,000
+CreditCard is a functional interface that declares one.
+
+233
+00:16:14,000 --> 00:16:15,000
+Massart is.
+
+234
+00:16:15,000 --> 00:16:19,000
+It takes one argument and the returns is a true or false.
+
+235
+00:16:19,000 --> 00:16:21,000
+So here is my function.
+
+236
+00:16:21,000 --> 00:16:25,000
+I pass full name and I check whether it contains Andry.
+
+237
+00:16:25,000 --> 00:16:33,000
+If yes, then I receive optional with this name when I call, or else I get the reference to my whole
+
+238
+00:16:33,000 --> 00:16:36,000
+name and bring that to console in a similar example.
+
+239
+00:16:36,000 --> 00:16:39,000
+But with a different name, I will get give empty optional.
+
+240
+00:16:40,000 --> 00:16:46,000
+And you can charge this by console output in the second case paren to console the false string that
+
+241
+00:16:46,000 --> 00:16:48,000
+they used in or else methods.
+
+242
+00:16:48,000 --> 00:16:56,000
+Do you understand why we may need to field the method that is normally used to reject wrapt values based
+
+243
+00:16:56,000 --> 00:16:57,000
+on the predefined tool?
+
+244
+00:16:58,000 --> 00:17:04,000
+Imagine now in another case we have a user object, and we need to make sure that the users that we
+
+245
+00:17:04,000 --> 00:17:11,000
+received from database or from another method has Mercier's less than one number than the more than
+
+246
+00:17:11,000 --> 00:17:12,000
+another number.
+
+247
+00:17:13,000 --> 00:17:14,000
+How to do that?
+
+248
+00:17:14,000 --> 00:17:22,000
+We can use map mass simply to convert the rabbit value to another type, Zimet, Mass, that allows
+
+249
+00:17:22,000 --> 00:17:26,000
+us to convert the value from one object to another.
+
+250
+00:17:26,000 --> 00:17:33,000
+If an optional is populated, this method can be thought of as a pipeline method, whereas the rabbit
+
+251
+00:17:33,000 --> 00:17:37,000
+value is passed along the pipeline and transform.
+
+252
+00:17:37,000 --> 00:17:41,000
+Can you value the remember how Stream API works?
+
+253
+00:17:42,000 --> 00:17:43,000
+This similar concept is here.
+
+254
+00:17:44,000 --> 00:17:50,000
+This method works by accepting the function object as it is applied to the rabbit value to produce the
+
+255
+00:17:50,000 --> 00:17:51,000
+mapped value.
+
+256
+00:17:52,000 --> 00:17:58,000
+Even the optional is empty, is a function object is never called, and an empty optional is returned
+
+257
+00:17:58,000 --> 00:18:00,000
+from the map massively.
+
+258
+00:18:00,000 --> 00:18:02,000
+Let me explain your own example.
+
+259
+00:18:02,000 --> 00:18:05,000
+I have optional parametrized by type user.
+
+260
+00:18:05,000 --> 00:18:07,000
+I have arrived here.
+
+261
+00:18:07,000 --> 00:18:08,000
+User object.
+
+262
+00:18:08,000 --> 00:18:14,000
+This user has named Igor and his universe is 1990s.
+
+263
+00:18:14,000 --> 00:18:21,000
+I call map Massart on my optional object to convert data in the pipeline from user to an end.
+
+264
+00:18:22,000 --> 00:18:27,000
+I need to pass functions that knows how to transform the current type thing.
+
+265
+00:18:28,000 --> 00:18:35,000
+And when I have int value in pipeline, I can use filter mass to check was a year of birth of the current
+
+266
+00:18:35,000 --> 00:18:38,000
+user is within the expected range.
+
+267
+00:18:38,000 --> 00:18:44,000
+In this case, my user matches the current filters and optional was very is returned.
+
+268
+00:18:45,000 --> 00:18:49,000
+That's why I can print the user's Berthier tokens.
+
+269
+00:18:49,000 --> 00:18:55,000
+So what does this example please let me know in case you have any questions in case something is still
+
+270
+00:18:55,000 --> 00:18:56,000
+unclear.
+
+271
+00:18:56,000 --> 00:18:57,000
+Please.
+
+272
+00:18:57,000 --> 00:18:59,000
+What's your question below this video?
+
+273
+00:18:59,000 --> 00:19:02,000
+And there will be happy to answer it.
+
+274
+00:19:02,000 --> 00:19:06,000
+Let's review another method that is similar to those in Map Mass.
+
+275
+00:19:06,000 --> 00:19:11,000
+Let's have the flat map Masset as an alternative for values transformation.
+
+276
+00:19:12,000 --> 00:19:15,000
+There is one main difference between these two masses.
+
+277
+00:19:15,000 --> 00:19:21,000
+The difference is that map transforms values only when Xe unwrap.
+
+278
+00:19:21,000 --> 00:19:27,000
+Whereas flat map takes a wrapped value and unwraps it before transforming it.
+
+279
+00:19:28,000 --> 00:19:32,000
+Let's make sure that you understood this following Z example.
+
+280
+00:19:32,000 --> 00:19:41,000
+So imagine that we keep working with the same user, but interested in sync in a mass returns, optional
+
+281
+00:19:41,000 --> 00:19:45,000
+to, for example, get name Massart, which is optional.
+
+282
+00:19:45,000 --> 00:19:47,000
+It is parametrized by string.
+
+283
+00:19:48,000 --> 00:19:48,000
+No.
+
+284
+00:19:48,000 --> 00:19:54,000
+And all what we know that's extracted from the optional parameterized by type user.
+
+285
+00:19:55,000 --> 00:20:00,000
+The first thing that I do, I want to convert optional of user to the just name.
+
+286
+00:20:00,000 --> 00:20:01,000
+What I got instead.
+
+287
+00:20:02,000 --> 00:20:07,000
+Instead, I got optional parameterized by optional the disbursements surprised by string.
+
+288
+00:20:07,000 --> 00:20:11,000
+That is because my get name Masset returns optional.
+
+289
+00:20:11,000 --> 00:20:16,000
+Having this wrapper, I can extract optional parameterized by a string.
+
+290
+00:20:17,000 --> 00:20:22,000
+It should contain the name of the user, and only after that I can extract user.
+
+291
+00:20:23,000 --> 00:20:30,000
+Don't you think that they added a lot of redundant steps similar to the Stream API from Jaedicke?
+
+292
+00:20:30,000 --> 00:20:35,000
+So that map doesn't rabs the value was additional optional.
+
+293
+00:20:35,000 --> 00:20:42,000
+So to achieve the same goal in a little bit simpler way is to call threads, map and parse the references
+
+294
+00:20:42,000 --> 00:20:43,000
+to get name message.
+
+295
+00:20:44,000 --> 00:20:49,000
+And now I can apply Ozz masses to extract value like or message.
+
+296
+00:20:50,000 --> 00:20:54,000
+And in console, you can see that the results are the same.
+
+297
+00:20:54,000 --> 00:20:59,000
+But the second option, Dukas, less lines of code to achieve is the same result.
+
+298
+00:20:59,000 --> 00:21:00,000
+Does it make sense?
+
+299
+00:21:01,000 --> 00:21:08,000
+In my opinion, we have removed all the most important masses from optional API that might come in handy.
+
+300
+00:21:08,000 --> 00:21:15,000
+But any way opens a source code of GMU to optional class by yourself and investigated.
+
+301
+00:21:15,000 --> 00:21:21,000
+Now let's discuss when and how to use optional to make sure it is not dangerous and you don't bring
+
+302
+00:21:21,000 --> 00:21:23,000
+more harm than good.
+
+303
+00:21:24,000 --> 00:21:27,000
+Let's review different parts of our program and different use cases.
+
+304
+00:21:28,000 --> 00:21:30,000
+And I will give you my advice.
+
+305
+00:21:30,000 --> 00:21:31,000
+Return values.
+
+306
+00:21:32,000 --> 00:21:35,000
+Often optionals are well suited for a chance values.
+
+307
+00:21:36,000 --> 00:21:43,000
+Originally, this was intended to be zem main use case in documentation that we can find.
+
+308
+00:21:43,000 --> 00:21:44,000
+Is it optional?
+
+309
+00:21:44,000 --> 00:21:52,000
+Type is primarily intended for use as a message, Chantae, where there is a growing need to represent
+
+310
+00:21:52,000 --> 00:21:53,000
+no result.
+
+311
+00:21:53,000 --> 00:21:57,000
+And we're using now is likely to cause errors.
+
+312
+00:21:57,000 --> 00:22:04,000
+And here I'd like to pay you extra attention in order you wouldn't follow code style of colleague of
+
+313
+00:22:04,000 --> 00:22:08,000
+mine who has all methods developed this optional type return.
+
+314
+00:22:09,000 --> 00:22:16,000
+You should return optional as of this set where there is a clear need to represent no result.
+
+315
+00:22:17,000 --> 00:22:22,000
+And we're using now is likely to cause errors, not everywhere.
+
+316
+00:22:23,000 --> 00:22:27,000
+But still, this recommendation leaves error for interpretations.
+
+317
+00:22:27,000 --> 00:22:30,000
+I would also add one more important thing to consider.
+
+318
+00:22:31,000 --> 00:22:38,000
+Use optional only in cases when you want to make client of your code responsible for handling of absent
+
+319
+00:22:38,000 --> 00:22:39,000
+value.
+
+320
+00:22:39,000 --> 00:22:43,000
+And this is really a good reason not to put optional the chandab everywhere.
+
+321
+00:22:44,000 --> 00:22:44,000
+Why?
+
+322
+00:22:45,000 --> 00:22:52,000
+Because in most cases, we need to provide ready to use API, but not make our clients seeing about
+
+323
+00:22:52,000 --> 00:22:58,000
+each return value, what to do in case value wasn't returned regarding the fields.
+
+324
+00:22:59,000 --> 00:23:00,000
+Let me put it simple.
+
+325
+00:23:00,000 --> 00:23:04,000
+You can create fields of optional type, but you shouldn't.
+
+326
+00:23:04,000 --> 00:23:05,000
+Why?
+
+327
+00:23:05,000 --> 00:23:08,000
+For me, it is a sign of a bad architecture.
+
+328
+00:23:08,000 --> 00:23:13,000
+You have fields known from the beginning that they may not be initialized.
+
+329
+00:23:13,000 --> 00:23:20,000
+But in this case, you have met Iraqui and that or the architecture was not implemented.
+
+330
+00:23:20,000 --> 00:23:21,000
+Solid principles.
+
+331
+00:23:21,000 --> 00:23:27,000
+Probably there are some classes that don't need all these fields, and it is just a matter of building
+
+332
+00:23:27,000 --> 00:23:29,000
+of proper Iraqui.
+
+333
+00:23:29,000 --> 00:23:30,000
+A lot of questions.
+
+334
+00:23:30,000 --> 00:23:36,000
+So I'll put it simple, the not to use optionals in fields parameters.
+
+335
+00:23:36,000 --> 00:23:39,000
+You can use optional methods, parameters.
+
+336
+00:23:39,000 --> 00:23:42,000
+But again, it is not recommended to do that.
+
+337
+00:23:42,000 --> 00:23:45,000
+It is recommended instead to have law that.
+
+338
+00:23:46,000 --> 00:23:53,000
+If you know that, you might need to invoke this method with no parameter or this empty optional, in
+
+339
+00:23:53,000 --> 00:23:53,000
+other words.
+
+340
+00:23:54,000 --> 00:23:57,000
+So just with mass, that takes no parameter.
+
+341
+00:23:58,000 --> 00:24:04,000
+But you also can have our law that was the same name, but which takes parameter.
+
+342
+00:24:04,000 --> 00:24:05,000
+Is that clear?
+
+343
+00:24:05,000 --> 00:24:09,000
+Some students ask me what is alternative to use an optional.
+
+344
+00:24:10,000 --> 00:24:15,000
+Well, the simplest alternative is to leave like our ancestors left.
+
+345
+00:24:15,000 --> 00:24:19,000
+Just use no value and do not forget, put no checks.
+
+346
+00:24:20,000 --> 00:24:23,000
+This is still the case in a lot of programs nowadays.
+
+347
+00:24:23,000 --> 00:24:30,000
+Another alternative might be a sort of an exception if absence of the value really brigg's the way of
+
+348
+00:24:30,000 --> 00:24:31,000
+your program execution.
+
+349
+00:24:32,000 --> 00:24:37,000
+Then you need to be prepared to handle specific exception and to handle it properly.
+
+350
+00:24:37,000 --> 00:24:42,000
+During the handling of this exception, you specify 70 fractions.
+
+351
+00:24:42,000 --> 00:24:45,000
+What is needed to be done in case the value is absent?
+
+352
+00:24:46,000 --> 00:24:48,000
+Almost a similar way you do with optional.
+
+353
+00:24:49,000 --> 00:24:51,000
+And another alternative is no objects.
+
+354
+00:24:51,000 --> 00:24:58,000
+You can create a time that has the same API, but it is empty inside and all my are error safe.
+
+355
+00:24:59,000 --> 00:25:01,000
+And when it is seen, you just create.
+
+356
+00:25:01,000 --> 00:25:07,000
+Instance of the empty object or just parcels, a reference to that empty constantly, for example,
+
+357
+00:25:07,000 --> 00:25:10,000
+in collections, glossaries, empty, list constant.
+
+358
+00:25:11,000 --> 00:25:14,000
+And instead of returning, no one least is expected.
+
+359
+00:25:15,000 --> 00:25:16,000
+You can just return empty.
+
+360
+00:25:16,000 --> 00:25:22,000
+These constant that will save you from no point exception remembers use of devices.
+
+361
+00:25:23,000 --> 00:25:27,000
+They're years of experience and millions of dollars behind these advices.
+
+362
+00:25:28,000 --> 00:25:31,000
+Let's recap what we have learned in this lesson.
+
+363
+00:25:31,000 --> 00:25:32,000
+In this lesson we learned.
+
+364
+00:25:33,000 --> 00:25:35,000
+Optional class API and its methods.
+
+365
+00:25:36,000 --> 00:25:39,000
+It knows the purpose of the optional and when to use it.
+
+366
+00:25:39,000 --> 00:25:46,000
+And at the end of the lesson, I also explained few alternative techniques to use instead of optional.
+
+367
+00:25:46,000 --> 00:25:48,000
+That's all for this lesson.
+
+368
+00:25:48,000 --> 00:25:49,000
+Thanks a lot for your attention.
+
+369
+00:25:50,000 --> 00:25:52,000
+Have a great day and see you in the next lesson.
+

31 - JDK API/003 Reactive Programming in Java Flow API, Reactive Streams_en.srt

@@ -0,0 +1,996 @@
+1
+00:00:05,000 --> 00:00:11,000
+Hello dear students, in this lesson we are going to learn what reactive programming is and how we can
+
+2
+00:00:11,000 --> 00:00:16,000
+apply reactive programming practices using Java via flow API.
+
+3
+00:00:16,000 --> 00:00:20,000
+We are going to start the lesson from learning general concepts.
+
+4
+00:00:20,000 --> 00:00:23,000
+We'll learn what reactive programming approach is.
+
+5
+00:00:23,000 --> 00:00:29,000
+We'll discuss what the most popular libraries for reactive programming in Java are.
+
+6
+00:00:29,000 --> 00:00:36,000
+But in scope of this lesson, we will focus our attention on the flow API that is available in JDK for
+
+7
+00:00:36,000 --> 00:00:38,000
+reactive programming.
+
+8
+00:00:38,000 --> 00:00:39,000
+As we will go.
+
+9
+00:00:39,000 --> 00:00:45,000
+We'll learn different terms like for example Backpressure aware concept.
+
+10
+00:00:45,000 --> 00:00:49,000
+We'll learn key interfaces from flow API.
+
+11
+00:00:49,000 --> 00:00:51,000
+Then we'll talk about use cases.
+
+12
+00:00:51,000 --> 00:00:57,000
+And I will try to answer the question when it is recommended to use reactive programming approach.
+
+13
+00:00:57,000 --> 00:01:04,000
+And at the end of the lesson we are going to review code examples in order to understand how reactive
+
+14
+00:01:04,000 --> 00:01:06,000
+streams work on practice.
+
+15
+00:01:06,000 --> 00:01:08,000
+Let's start our lesson.
+
+16
+00:01:09,000 --> 00:01:12,000
+Let's start from learning of what reactive programming is.
+
+17
+00:01:13,000 --> 00:01:20,000
+Reactive programming is a programming paradigm focused on handling asynchronous data streams and the
+
+18
+00:01:20,000 --> 00:01:22,000
+propagation of changes.
+
+19
+00:01:22,000 --> 00:01:29,000
+It provides a set of principles, patterns, and libraries that enable developers to build responsive
+
+20
+00:01:29,000 --> 00:01:36,000
+and scalable systems, especially in the context of handling events, input output operations, and
+
+21
+00:01:36,000 --> 00:01:37,000
+real time data.
+
+22
+00:01:38,000 --> 00:01:41,000
+Let's review key characteristics of reactive programming.
+
+23
+00:01:41,000 --> 00:01:45,000
+They include asynchronous and non-blocking.
+
+24
+00:01:46,000 --> 00:01:51,000
+Reactive programming emphasizes asynchronous and non-blocking operations.
+
+25
+00:01:51,000 --> 00:01:58,000
+It allows components to continue processing other tasks while waiting for asynchronous operations to
+
+26
+00:01:58,000 --> 00:02:02,000
+complete, leading to more efficient resource utilization.
+
+27
+00:02:03,000 --> 00:02:04,000
+Data streams.
+
+28
+00:02:04,000 --> 00:02:09,000
+At the core of reactive programming is the concept of data streams.
+
+29
+00:02:09,000 --> 00:02:13,000
+Sequences of events or values that occur over time.
+
+30
+00:02:13,000 --> 00:02:21,000
+These streams can represent various types of data such as user inputs, sensor readings, or messages
+
+31
+00:02:21,000 --> 00:02:22,000
+from a server.
+
+32
+00:02:23,000 --> 00:02:30,000
+Event-driven reactive systems are often event driven, meaning they respond to events or changes in
+
+33
+00:02:30,000 --> 00:02:31,000
+the system.
+
+34
+00:02:31,000 --> 00:02:37,000
+Events can trigger reactions and the system adapts dynamically to these changes.
+
+35
+00:02:38,000 --> 00:02:39,000
+Back pressure.
+
+36
+00:02:40,000 --> 00:02:43,000
+Back pressure is a key concept in reactive programming.
+
+37
+00:02:43,000 --> 00:02:51,000
+It refers to the ability of downstream component to signal its capacity to handle data to an upstream
+
+38
+00:02:51,000 --> 00:02:52,000
+component.
+
+39
+00:02:52,000 --> 00:02:59,000
+This helps prevent overwhelming the system with more data than it can process efficiently.
+
+40
+00:03:00,000 --> 00:03:02,000
+Responsive and scalable.
+
+41
+00:03:02,000 --> 00:03:09,000
+Reactive programming aims to create responsive applications that can handle varied workloads.
+
+42
+00:03:09,000 --> 00:03:17,000
+By embracing asynchrony and scalability, reactive systems can efficiently adapt to changes in demand.
+
+43
+00:03:18,000 --> 00:03:20,000
+Functional programming.
+
+44
+00:03:20,000 --> 00:03:25,000
+Reactive programming often aligns with functional programming principles.
+
+45
+00:03:25,000 --> 00:03:33,000
+It emphasizes immutability, pure functions, and the use of higher order functions, enabling developers
+
+46
+00:03:33,000 --> 00:03:36,000
+to write more concise and maintainable code.
+
+47
+00:03:37,000 --> 00:03:39,000
+Reactive extensions.
+
+48
+00:03:39,000 --> 00:03:47,000
+Reactive extensions, often referred to as RCS, is a set of libraries that provide a uniform way to
+
+49
+00:03:47,000 --> 00:03:52,000
+work with reactive programming concepts across multiple programming languages.
+
+50
+00:03:53,000 --> 00:03:58,000
+RCS libraries exist for languages like Java, JavaScript, C, sharp, and more.
+
+51
+00:03:59,000 --> 00:04:05,000
+Reactive programming has become popular in building modern applications, especially those that involve
+
+52
+00:04:05,000 --> 00:04:10,000
+real time data, user interfaces, and distributed systems.
+
+53
+00:04:10,000 --> 00:04:18,000
+Frameworks and libraries like Project Reactor, Erik's Java provide tools and abstractions to implement
+
+54
+00:04:18,000 --> 00:04:21,000
+reactive programming in various programming languages.
+
+55
+00:04:22,000 --> 00:04:29,000
+These tools simplify the handling of asynchronous and streaming data, making it easier for developers
+
+56
+00:04:29,000 --> 00:04:32,000
+to build responsive and scalable applications.
+
+57
+00:04:33,000 --> 00:04:40,000
+In Java, reactive programming approach may be implemented with different libraries, for example a
+
+58
+00:04:40,000 --> 00:04:42,000
+Java reactor core.
+
+59
+00:04:42,000 --> 00:04:52,000
+Reactive streams are socket martini reactor, but starting from Java version nine, you can use JDK
+
+60
+00:04:52,000 --> 00:04:55,000
+to implement reactive programming approach.
+
+61
+00:04:55,000 --> 00:04:59,000
+Flow API is available starting from Java nine.
+
+62
+00:04:59,000 --> 00:05:02,000
+In this lesson we will focus on flow API.
+
+63
+00:05:03,000 --> 00:05:05,000
+So let's learn what a flow API is.
+
+64
+00:05:06,000 --> 00:05:14,000
+The flow API, also known as Reactive Streams, was introduced in Java nine to address challenges associated
+
+65
+00:05:14,000 --> 00:05:21,000
+with asynchronous programming and handling streams of data in a more efficient and scalable way.
+
+66
+00:05:21,000 --> 00:05:28,000
+Reactive streams provide a standard for asynchronous stream processing with non-blocking back pressure,
+
+67
+00:05:28,000 --> 00:05:33,000
+enabling better control over the flow of data between components.
+
+68
+00:05:33,000 --> 00:05:40,000
+Reactive streams define a set of interfaces, classes, and masses that standardize the exchange of
+
+69
+00:05:40,000 --> 00:05:46,000
+asynchronous data streams between components in a non-blocking, back pressure aware manner.
+
+70
+00:05:47,000 --> 00:05:51,000
+Now let me share with you key interfaces in the flow API.
+
+71
+00:05:51,000 --> 00:05:58,000
+So the main interfaces include publisher, subscriber, subscription and processor.
+
+72
+00:05:58,000 --> 00:06:05,000
+I will make just a brief overview of them and we will learn more during the review of real life example.
+
+73
+00:06:06,000 --> 00:06:13,000
+Publisher amidst a potentially unbounded sequence of elements to one or more subscribers.
+
+74
+00:06:14,000 --> 00:06:22,000
+Subscriber consumes elements from a publisher and signals when it can handle more elements.
+
+75
+00:06:22,000 --> 00:06:30,000
+Subscription represents the link between a subscriber and a publisher, allowing the subscriber to request
+
+76
+00:06:30,000 --> 00:06:31,000
+and cancel elements.
+
+77
+00:06:32,000 --> 00:06:33,000
+Processor.
+
+78
+00:06:34,000 --> 00:06:43,000
+The processor interface in the Reactive Streams API serves as a dual role component, acting both as
+
+79
+00:06:43,000 --> 00:06:49,000
+a subscriber and a publisher, enabling custom data processing within a reactive stream.
+
+80
+00:06:50,000 --> 00:06:55,000
+So let's try to answer the question why flow API is needed?
+
+81
+00:06:55,000 --> 00:07:02,000
+Traditional stream processing in Java lacked a standardized way to handle asynchronous data streams,
+
+82
+00:07:02,000 --> 00:07:09,000
+which could lead to issues like buffer overflow or excessive resource consumption.
+
+83
+00:07:09,000 --> 00:07:16,000
+Reactive streams address these problems by introducing Backpressure, allowing subscribers to signal
+
+84
+00:07:16,000 --> 00:07:22,000
+when they are ready to receive more data, preventing overwhelming downstream components.
+
+85
+00:07:22,000 --> 00:07:26,000
+And in which cases it is recommended to use flow API.
+
+86
+00:07:27,000 --> 00:07:29,000
+Asynchronous processing.
+
+87
+00:07:29,000 --> 00:07:36,000
+Reactive streams are beneficial in scenarios where asynchronous processing is required, such as handling
+
+88
+00:07:36,000 --> 00:07:40,000
+events, input output operations, or real time data.
+
+89
+00:07:41,000 --> 00:07:48,000
+Backpressure handling when dealing with data streams, where the rate of data production is different
+
+90
+00:07:48,000 --> 00:07:50,000
+from the rate of data consumption.
+
+91
+00:07:50,000 --> 00:07:56,000
+Reactive streams help manage backpressure, preventing overwhelming downstream components.
+
+92
+00:07:57,000 --> 00:08:00,000
+Scalable and responsive applications.
+
+93
+00:08:01,000 --> 00:08:02,000
+Reactive programming was.
+
+94
+00:08:02,000 --> 00:08:09,000
+Reactive Streams is well suited for building responsive and scalable applications, especially in scenarios
+
+95
+00:08:09,000 --> 00:08:13,000
+like web services, where responsiveness is crucial.
+
+96
+00:08:14,000 --> 00:08:16,000
+Use reactive streams when you need to.
+
+97
+00:08:17,000 --> 00:08:20,000
+Handle asynchronous data streams.
+
+98
+00:08:20,000 --> 00:08:26,000
+Implement Backpressure to control the flow of data and prevent resource exhaustion.
+
+99
+00:08:26,000 --> 00:08:34,000
+Build scalable and responsive applications with non-blocking input output operations.
+
+100
+00:08:35,000 --> 00:08:41,000
+Reactive streams have gained popularity in modern Java development and are widely used in frameworks
+
+101
+00:08:41,000 --> 00:08:46,000
+like Project Reactor to build reactive and resilient systems.
+
+102
+00:08:46,000 --> 00:08:52,000
+I believe we learned enough theory, and now we are ready to review examples that I prepared especially
+
+103
+00:08:52,000 --> 00:08:53,000
+for this lesson.
+
+104
+00:08:54,000 --> 00:09:00,000
+You can find the source code of examples that I am going to share with you in attachments to the lesson.
+
+105
+00:09:00,000 --> 00:09:06,000
+Remember, Tim, that you are always welcome to ask questions in case something is not clear.
+
+106
+00:09:06,000 --> 00:09:11,000
+Just post your question below the video and I will be happy to answer.
+
+107
+00:09:11,000 --> 00:09:17,000
+As you can see, examples related to reactive streams are in flow API package.
+
+108
+00:09:18,000 --> 00:09:22,000
+We're going to start review from the flow API example class.
+
+109
+00:09:22,000 --> 00:09:26,000
+This is a class where I put client code and main method.
+
+110
+00:09:27,000 --> 00:09:30,000
+So we will go together with the flow of execution.
+
+111
+00:09:30,000 --> 00:09:34,000
+And I will explain you what is happening here line by line.
+
+112
+00:09:34,000 --> 00:09:39,000
+Let me also run this file in order to have all console output printed.
+
+113
+00:09:39,000 --> 00:09:43,000
+And you will be able to see the sequence of events that is happening here.
+
+114
+00:09:44,000 --> 00:09:51,000
+Pay attention that today we will review types that are stored on the Java.util.concurrent package inside
+
+115
+00:09:51,000 --> 00:09:53,000
+final class flow.
+
+116
+00:09:53,000 --> 00:10:00,000
+There are such important interfaces as publisher, subscriber, subscription and processor.
+
+117
+00:10:00,000 --> 00:10:03,000
+These are types that we are going to use today.
+
+118
+00:10:04,000 --> 00:10:07,000
+I start example from creation of the submission publisher.
+
+119
+00:10:08,000 --> 00:10:15,000
+The submission publisher is a built in implementation of the publisher interface in Java Flow API.
+
+120
+00:10:15,000 --> 00:10:23,000
+It emits a potentially unbounded sequence of elements, in this case integers to one or more subscribers.
+
+121
+00:10:24,000 --> 00:10:29,000
+The next thing I create instance of my subscriber.
+
+122
+00:10:29,000 --> 00:10:36,000
+It is parametrized by integer type because in this example I plan to receive integer elements.
+
+123
+00:10:36,000 --> 00:10:42,000
+To implement subscriber interface, you need to give implementation to all following methods.
+
+124
+00:10:42,000 --> 00:10:45,000
+Let's review each of them one by one.
+
+125
+00:10:46,000 --> 00:10:48,000
+Unsubscribe method.
+
+126
+00:10:48,000 --> 00:10:56,000
+This method signals about the subscription sets the subscription object, and requests the first item
+
+127
+00:10:56,000 --> 00:10:59,000
+to initialize the data flow with the provided subscription.
+
+128
+00:11:00,000 --> 00:11:07,000
+Basically, with the request method, you create demand for elements that subscriber can process depending
+
+129
+00:11:07,000 --> 00:11:13,000
+on the amount of requested elements, the same amount of times on next method will be invoked.
+
+130
+00:11:14,000 --> 00:11:16,000
+On next method.
+
+131
+00:11:16,000 --> 00:11:21,000
+This method processes in common integer items.
+
+132
+00:11:21,000 --> 00:11:28,000
+In our example, I just double all in common integers and transform them to string just for the sake
+
+133
+00:11:28,000 --> 00:11:34,000
+of example, because theoretically we can implement processor interface that I am going to explain a
+
+134
+00:11:34,000 --> 00:11:42,000
+little bit later, and you can supply process data downstream in such way you can build processing chain
+
+135
+00:11:42,000 --> 00:11:43,000
+and data flow.
+
+136
+00:11:44,000 --> 00:11:48,000
+That's why I created submit method just for the sake of example.
+
+137
+00:11:48,000 --> 00:11:55,000
+And just to show you that in submit method, you can put the logic of processed item submission downstream
+
+138
+00:11:55,000 --> 00:11:56,000
+in simple words.
+
+139
+00:11:56,000 --> 00:12:03,000
+Send processed item further down the processing chain depending on your business logic.
+
+140
+00:12:04,000 --> 00:12:12,000
+Onerror method handles errors during processing by printing an error message, allowing the processor
+
+141
+00:12:12,000 --> 00:12:15,000
+to respond appropriately to error conditions.
+
+142
+00:12:16,000 --> 00:12:20,000
+On complete signals, the completion of processing.
+
+143
+00:12:20,000 --> 00:12:24,000
+Printing a message to indicate the end of the data stream.
+
+144
+00:12:24,000 --> 00:12:31,000
+If you build a longer processing chain, this is the method where you can notify downstream components
+
+145
+00:12:31,000 --> 00:12:36,000
+that processing is completed, and in this method I cancel subscription.
+
+146
+00:12:37,000 --> 00:12:40,000
+Let's get back to flow API example class.
+
+147
+00:12:41,000 --> 00:12:49,000
+The next thing that I do here I subscribe my subscriber to publisher in the context of the Reactive
+
+148
+00:12:49,000 --> 00:12:50,000
+Streams API.
+
+149
+00:12:50,000 --> 00:12:57,000
+The relationship between a publisher and a subscriber is established through the subscribe method.
+
+150
+00:12:57,000 --> 00:13:04,000
+However, it is important to note that it is the publisher who initiates the subscription process by
+
+151
+00:13:04,000 --> 00:13:08,000
+calling the subscribe method on the publisher object.
+
+152
+00:13:08,000 --> 00:13:11,000
+Now there will be a connection between them.
+
+153
+00:13:12,000 --> 00:13:19,000
+Publisher will be aware about subscriber and when this will happen, then unsubscribe method will be
+
+154
+00:13:19,000 --> 00:13:24,000
+triggered and I will initialize my subscription property inside.
+
+155
+00:13:25,000 --> 00:13:28,000
+But wait, something should be wrong here.
+
+156
+00:13:28,000 --> 00:13:34,000
+Where missing subscription object because we have publisher, we have subscriber.
+
+157
+00:13:34,000 --> 00:13:36,000
+But where is subscription object?
+
+158
+00:13:36,000 --> 00:13:41,000
+You can implement it by yourself by implementing subscription interface.
+
+159
+00:13:41,000 --> 00:13:43,000
+But what is happening in this case?
+
+160
+00:13:44,000 --> 00:13:50,000
+You can see that I decided to print subscription object to console in order to understand the type of
+
+161
+00:13:50,000 --> 00:13:51,000
+this object.
+
+162
+00:13:52,000 --> 00:13:54,000
+And we can see that we received here.
+
+163
+00:13:54,000 --> 00:13:56,000
+Object of type buffered subscription.
+
+164
+00:13:57,000 --> 00:14:01,000
+This is nested class inside submission publisher class.
+
+165
+00:14:01,000 --> 00:14:03,000
+But who created this object?
+
+166
+00:14:03,000 --> 00:14:10,000
+And when a buffered subscription is created when a subscriber subscribes to a submission publisher,
+
+167
+00:14:11,000 --> 00:14:17,000
+this subscription object manages the communication between the publisher and the subscriber, facilitating
+
+168
+00:14:17,000 --> 00:14:19,000
+the flow of data.
+
+169
+00:14:19,000 --> 00:14:21,000
+The charm buffer.
+
+170
+00:14:21,000 --> 00:14:28,000
+It suggests that this subscription might have some internal buffer to store items when the subscriber
+
+171
+00:14:28,000 --> 00:14:31,000
+can't keep up with the rate of data production.
+
+172
+00:14:32,000 --> 00:14:36,000
+Here is a breakdown of what happens during the subscription process.
+
+173
+00:14:37,000 --> 00:14:42,000
+Publisher calls subscribe method and subscribe subscriber object.
+
+174
+00:14:42,000 --> 00:14:47,000
+Submission publisher creates a buffered subscription object internally.
+
+175
+00:14:48,000 --> 00:14:51,000
+This is happening inside subscribe method.
+
+176
+00:14:51,000 --> 00:14:57,000
+If we would open the source code of subscribe method, we will see how instance of buffered subscription
+
+177
+00:14:57,000 --> 00:14:58,000
+is created.
+
+178
+00:14:59,000 --> 00:15:05,000
+Unsubscribe method is called on the subscriber with created buffered subscription.
+
+179
+00:15:05,000 --> 00:15:12,000
+The unsubscribe method is then invoked on the subscriber, passing the buffered subscription as an argument.
+
+180
+00:15:12,000 --> 00:15:17,000
+This allows the subscriber to request items and manage backpressure.
+
+181
+00:15:17,000 --> 00:15:24,000
+The buffered aspect of the subscription typically comes into play when the subscriber is unable to keep
+
+182
+00:15:24,000 --> 00:15:27,000
+up with the rate of data production.
+
+183
+00:15:27,000 --> 00:15:35,000
+In such cases, the buffered subscription may buffer items until the subscriber signals that it can
+
+184
+00:15:35,000 --> 00:15:38,000
+process more data by calling the request method.
+
+185
+00:15:39,000 --> 00:15:44,000
+So after subscription is happened, then I set the timeout.
+
+186
+00:15:45,000 --> 00:15:49,000
+We need this time out to make sure that subscription is created.
+
+187
+00:15:49,000 --> 00:15:56,000
+But using timeout is very primitive way that I decided to use for the sake of example.
+
+188
+00:15:56,000 --> 00:16:03,000
+In reality, ensuring that everyone is successfully subscribed in a reactive system can be a complicated
+
+189
+00:16:03,000 --> 00:16:09,000
+task, and the approach might depend on the specific requirements of your application.
+
+190
+00:16:10,000 --> 00:16:14,000
+Some points to consider using of countdown Lodge.
+
+191
+00:16:15,000 --> 00:16:17,000
+Using of completablefuture.
+
+192
+00:16:17,000 --> 00:16:22,000
+Using of timeout mechanism, including using it with completablefuture.
+
+193
+00:16:23,000 --> 00:16:26,000
+In my course Java from zero to first job.
+
+194
+00:16:26,000 --> 00:16:33,000
+I have multi-threading section where I explained in details API of countdown, Lodge, Completablefuture
+
+195
+00:16:33,000 --> 00:16:35,000
+and other things.
+
+196
+00:16:35,000 --> 00:16:38,000
+That's why I wouldn't stop too much on this right now.
+
+197
+00:16:39,000 --> 00:16:43,000
+In console you can see subscriber subscribed.
+
+198
+00:16:44,000 --> 00:16:52,000
+After the timeout, I declare a for loop with counter and I submit five integers using publisher object.
+
+199
+00:16:52,000 --> 00:17:00,000
+I submit them one by one, and in console you can see that publisher submits one element and subscriber
+
+200
+00:17:00,000 --> 00:17:01,000
+receives it.
+
+201
+00:17:01,000 --> 00:17:08,000
+Taking into account that println method is synchronized, text and console not necessarily represents
+
+202
+00:17:08,000 --> 00:17:15,000
+the exact sequence of events, but at least it can give us an understanding of what is going on.
+
+203
+00:17:15,000 --> 00:17:23,000
+Subscriber after receiving integers, doubles, received elements and prints them to console two and
+
+204
+00:17:23,000 --> 00:17:30,000
+when publisher is closed, subscriber got notified two and Oncomplete method is triggered.
+
+205
+00:17:31,000 --> 00:17:32,000
+And that's it.
+
+206
+00:17:32,000 --> 00:17:39,000
+Knowing this, you can build more complex data flows with multiple subscribers, different publishers.
+
+207
+00:17:39,000 --> 00:17:44,000
+You can connect them between each other as your business logic would require.
+
+208
+00:17:45,000 --> 00:17:51,000
+And the last but not the least thing that I would like to show you for today is processor interface.
+
+209
+00:17:52,000 --> 00:17:58,000
+You can create processor class that would implement processor interface if you want to make it acting
+
+210
+00:17:58,000 --> 00:18:02,000
+as both a publisher and a subscriber.
+
+211
+00:18:02,000 --> 00:18:06,000
+This can be helpful when you want to build a processing chain.
+
+212
+00:18:06,000 --> 00:18:13,000
+For example, you can receive some data from publisher, process it, and pass it further to the next
+
+213
+00:18:13,000 --> 00:18:14,000
+subscriber.
+
+214
+00:18:15,000 --> 00:18:15,000
+And like this.
+
+215
+00:18:15,000 --> 00:18:18,000
+You can build complex data flows.
+
+216
+00:18:18,000 --> 00:18:26,000
+So the processor interface in the Reactive Streams API is used when you need to create a component that
+
+217
+00:18:26,000 --> 00:18:29,000
+acts as a both a publisher and a subscriber.
+
+218
+00:18:29,000 --> 00:18:36,000
+It is particularly useful in scenarios where you want to transform or process the data flowing through
+
+219
+00:18:36,000 --> 00:18:40,000
+a reactive stream before it reaches the downstream subscribers.
+
+220
+00:18:41,000 --> 00:18:46,000
+Here are some situations where you might consider using the processor interface.
+
+221
+00:18:47,000 --> 00:18:50,000
+Transforming or processing data.
+
+222
+00:18:50,000 --> 00:18:57,000
+If you need to apply transformations, filtering or any other processing logic to the data before it
+
+223
+00:18:57,000 --> 00:19:03,000
+is delivered to subscribers, the processor interface allows you to implement this logic.
+
+224
+00:19:04,000 --> 00:19:07,000
+Connecting different parts of a reactive pipeline.
+
+225
+00:19:07,000 --> 00:19:13,000
+When you have a reactive pipeline with multiple stages, and you want to connect these stages with a
+
+226
+00:19:13,000 --> 00:19:20,000
+component that can both consume data from the upstream and emit processed data to the downstream.
+
+227
+00:19:21,000 --> 00:19:24,000
+Implementing a custom flow control mechanism.
+
+228
+00:19:24,000 --> 00:19:31,000
+If you need to implement a custom flow control mechanism between the publisher and subscribers, the
+
+229
+00:19:31,000 --> 00:19:38,000
+processor allows you to manage backpressure and control the rate at which data is consumed.
+
+230
+00:19:38,000 --> 00:19:41,000
+Aggregating or combining data streams.
+
+231
+00:19:41,000 --> 00:19:47,000
+When you want to combine or aggregate data from multiple publishers before delivering it to downstream
+
+232
+00:19:47,000 --> 00:19:49,000
+subscribers.
+
+233
+00:19:49,000 --> 00:19:52,000
+A processor can be used to implement the necessary logic.
+
+234
+00:19:53,000 --> 00:20:00,000
+If you check the source code of processor interface, then you will find that processor is a static
+
+235
+00:20:00,000 --> 00:20:05,000
+interface that extends subscriber and publisher at the same time.
+
+236
+00:20:05,000 --> 00:20:10,000
+In Java, an interface can extend multiple other interfaces.
+
+237
+00:20:10,000 --> 00:20:17,000
+This feature allows an interface to inherit abstract masses from multiple parent interfaces, providing
+
+238
+00:20:17,000 --> 00:20:22,000
+a way to express multiple types of behavior in a single interface.
+
+239
+00:20:22,000 --> 00:20:30,000
+So feel free to use processor interface implementations when it will be needed in your business cases.
+
+240
+00:20:30,000 --> 00:20:34,000
+That's all what I wanted to share with you today in this lesson.
+
+241
+00:20:34,000 --> 00:20:37,000
+Let's recap what we have learned in the video.
+
+242
+00:20:38,000 --> 00:20:41,000
+We learned reactive programming approach.
+
+243
+00:20:41,000 --> 00:20:45,000
+Now you know the most popular libraries for reactive programming in Java.
+
+244
+00:20:46,000 --> 00:20:54,000
+I explained you what flow API in JDK is, and we learned key interfaces and types in flow API.
+
+245
+00:20:54,000 --> 00:21:01,000
+I explained when and in which cases it is recommended to use Reactive Programming, Reactive Streams
+
+246
+00:21:01,000 --> 00:21:08,000
+flow API, and at the end of the lesson we reviewed code example in order to understand how it works
+
+247
+00:21:08,000 --> 00:21:09,000
+in practice.
+
+248
+00:21:09,000 --> 00:21:12,000
+That's all what I wanted to share with you today.
+
+249
+00:21:12,000 --> 00:21:15,000
+Have a great day and see you in the next lesson.
+

31 - JDK API/003 Source-code-examples-from-the-lesson.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/commit/d62a11591550fc4c8455d610c8ddbcf31c194b71

31 - JDK API/004 Quiz JDK API - Check yourself.html

@@ -0,0 +1,69 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>Quiz JDK API - Check yourself</title>
+
+        <style>
+            * {
+                box-sizing: border-box;
+                margin: 0;
+                padding: 0;
+            }
+            body {
+                font-family: var(--font-stack-text);
+                font-weight: 400;
+                line-height: 1.4;
+                font-size: 1.6rem;
+                color: #2d2f31;
+            }
+            .container {
+                position: relative;
+                height: 100%;
+                overflow-y: auto;
+            }
+            .content {
+                padding: 3.2rem 4.8rem;
+                word-break: break-word;
+                max-width: 69.6rem;
+                margin: 0 auto;
+            }
+            .heading {
+                margin-bottom: 24px;
+                font-family: -apple-system, BlinkMacSystemFont, Roboto, "Segoe UI", Helvetica, Arial, sans-serif,
+                    "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";
+                font-weight: 700;
+                line-height: 1.2;
+                letter-spacing: 0;
+                font-size: 32px;
+                max-width: 36em;
+            }
+            .article-asset-container {
+                padding: 2.4rem;
+            }
+            .article-asset-container p {
+                font-size: 19px;
+            }
+            code {
+                background-color: #fff;
+                border: 1px solid #d1d7dc;
+                color: #b4690e;
+                font-size: 80%;
+                padding: 0.2rem 0.4rem;
+                font-family: sfmono-regular, Consolas, liberation mono, Menlo, Courier, monospace;
+            }
+            p {
+                font-weight: 400;
+            }
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <div class="content">
+                <div class="heading">Quiz JDK API - Check yourself</div>
+                <div class="article-asset-container"><p><strong>Quiz Link: </strong><a href="https://forms.gle/LBnM5Sc5PXE71h6w6" rel="noopener noreferrer" target="_blank"><strong>https://forms.gle/LBnM5Sc5PXE71h6w6</strong></a></p><p>The quiz doesn’t require you to log in or submit any personal information. Your data privacy is my priority.</p><p>The Quiz covers content from the following lessons:</p><ul><li><p>StringBuilder &amp; StringBuffer</p></li><li><p>java.util.Optional - Optional in Java</p></li><li><p>Reactive Programming in Java: Flow API, Reactive Streams</p></li></ul><p><br></p><p><strong>Quiz Instructions:</strong></p><p>This quiz is designed to help you check your understanding of the content from the previous lessons. All questions are based only on material covered in the lessons you've already watched, so there’s no need to worry about unfamiliar topics.</p><ul><li><p>Each question has one correct answer. Select the best answer and click "Submit" when you're ready.</p></li><li><p>After submitting, you'll see your score. For each question, you earn 1 point.</p></li><li><p>Click "View Results" to see the explanations for each correct answer. Reviewing these explanations can help reinforce your understanding.</p></li><li><p>If you score below 70%, I recommend revisiting the previous lessons. However, if the explanations make sense and you’re confident in your understanding, feel free to move on.</p></li><li><p>If any explanations are unclear, please don’t hesitate to post questions in the Q&amp;A section—I’m here to help!</p></li></ul></div>
+            </div>
+        </div>
+    </body>
+</html>

31 - JDK API/external-links.txt

@@ -0,0 +1,9 @@
+
+001 Source-code-from-the-lesson
+https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/string/stringbuilder
+
+002 Source-code-examples-from-the-lesson
+https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/optional
+
+003 Source-code-examples-from-the-lesson
+https://github.com/AndriiPiatakha/learnit_java_core/commit/d62a11591550fc4c8455d610c8ddbcf31c194b71

32 - Java Platform Module System Modules in Java & Migration of Java Apps/001 Modules in Java Modular Application Example_en.srt

@@ -0,0 +1,1576 @@
+1
+00:00:06,000 --> 00:00:11,000
+Hello, the students in this lesson, we're going to learn more about features it was added in Java
+
+2
+00:00:11,000 --> 00:00:12,000
+version nine.
+
+3
+00:00:12,000 --> 00:00:14,000
+I'm talking about modules in Java.
+
+4
+00:00:14,000 --> 00:00:21,000
+There we have really a lot of new things to learn modules, really powerful features that exist in Java
+
+5
+00:00:21,000 --> 00:00:22,000
+platform.
+
+6
+00:00:22,000 --> 00:00:28,000
+And if you want to become Java software engineer or get one of Oracle certifications, you have to be
+
+7
+00:00:28,000 --> 00:00:29,000
+familiar with it.
+
+8
+00:00:29,000 --> 00:00:38,000
+We'll start lesson from simple and general topics such as what models are and just talking about why
+
+9
+00:00:38,000 --> 00:00:42,000
+we might need them to help you understand modules better.
+
+10
+00:00:42,000 --> 00:00:49,000
+I will explain what goals we are trying to achieve by using them and what benefits we expect to get.
+
+11
+00:00:50,000 --> 00:00:52,000
+We'll review different module types.
+
+12
+00:00:53,000 --> 00:01:00,000
+After that, we'll learn module directives that we use in the module descriptor and common line options
+
+13
+00:01:00,000 --> 00:01:05,000
+that might come in handy when you will work with multiple modules from Consult.
+
+14
+00:01:05,000 --> 00:01:12,000
+And at the end of the lesson, we're going to create modular Hello World application, and I will show
+
+15
+00:01:12,000 --> 00:01:18,000
+you how to configure it leaves and either you can work with this modular application from Eclipse.
+
+16
+00:01:19,000 --> 00:01:22,000
+As you can see, we have really a lot of things to do.
+
+17
+00:01:22,000 --> 00:01:24,000
+Let's start our lesson.
+
+18
+00:01:25,000 --> 00:01:28,000
+Let's understand first what modules are.
+
+19
+00:01:28,000 --> 00:01:37,000
+Module is a Nicklin named reusable group of related packages, as well as resources such as images and
+
+20
+00:01:37,000 --> 00:01:39,000
+Xolo files and module.
+
+21
+00:01:39,000 --> 00:01:44,000
+The specifying the modules name Xen Modules dependencies.
+
+22
+00:01:44,000 --> 00:01:46,000
+These are the other modules.
+
+23
+00:01:46,000 --> 00:01:49,000
+This module depends on zip packages.
+
+24
+00:01:49,000 --> 00:01:52,000
+It explicitly makes available to other modules.
+
+25
+00:01:53,000 --> 00:02:00,000
+All other packages in the module I implicitly unavailable to other modules, just services it offers,
+
+26
+00:02:01,000 --> 00:02:06,000
+the services it consumes, but what other modules it allows?
+
+27
+00:02:06,000 --> 00:02:12,000
+Reflection and General Module is a packaging mechanism that enables you to package a Java application
+
+28
+00:02:13,000 --> 00:02:21,000
+or Java API as a separate Java module and general module is packaged as Modular Jar File and Java module
+
+29
+00:02:21,000 --> 00:02:24,000
+can specify which of Java packages it contains.
+
+30
+00:02:24,000 --> 00:02:28,000
+That should be visible to OSR Java modules, which he uses.
+
+31
+00:02:28,000 --> 00:02:36,000
+This module and you have a module must also specify which OSI Jumo modules are required to do its job.
+
+32
+00:02:37,000 --> 00:02:45,000
+In most single words, Java module is a package for packages that is super simplified, but hope this
+
+33
+00:02:45,000 --> 00:02:48,000
+will help you to understand this concept.
+
+34
+00:02:48,000 --> 00:02:55,000
+You can group packages into modules and to ensure encapsulation, you may control access to different
+
+35
+00:02:55,000 --> 00:02:57,000
+packages within the module.
+
+36
+00:02:57,000 --> 00:03:02,000
+Modularity as higher level of a nation above packages is a clear.
+
+37
+00:03:03,000 --> 00:03:06,000
+Java Modules is a new feature in Java nine.
+
+38
+00:03:07,000 --> 00:03:15,000
+We as a Java Platform Module System Z Java Platform Module System is also sometimes referred to as Java,
+
+39
+00:03:15,000 --> 00:03:20,000
+Jigsaw or Project Jigsaw, depending on where you read.
+
+40
+00:03:20,000 --> 00:03:25,000
+Jigsaw was internally used project name during development.
+
+41
+00:03:25,000 --> 00:03:29,000
+Later, Jigsaw changed the name to Java Platform Module system.
+
+42
+00:03:30,000 --> 00:03:37,000
+There is a juicer 376 Juicer stands for Java specification request.
+
+43
+00:03:37,000 --> 00:03:45,000
+This is an actual description of proposed and final specification for the Java platform at any one time.
+
+44
+00:03:45,000 --> 00:03:49,000
+There are numerous juicers movies with a review and approval process.
+
+45
+00:03:50,000 --> 00:03:55,000
+In the Juicer 376, we can find list of goals of modular.
+
+46
+00:03:55,000 --> 00:04:02,000
+Ryzen is a Java Sea platform, and one them such goals as a reliable configuration.
+
+47
+00:04:03,000 --> 00:04:10,000
+Modularity provides mechanisms for explicitly declaring dependencies between modules in a manner that's
+
+48
+00:04:10,000 --> 00:04:14,000
+recognized both at compile time and execution time.
+
+49
+00:04:15,000 --> 00:04:16,000
+The system can work.
+
+50
+00:04:16,000 --> 00:04:24,000
+Suzy's Dependencies commands a subset of all modules required to support your app from Gemini nine and
+
+51
+00:04:24,000 --> 00:04:33,000
+forward Java applications must be packaged as Java Modules two zero four and application modules specifies
+
+52
+00:04:33,000 --> 00:04:38,000
+what OSM modules Java API modules supporting modules.
+
+53
+00:04:38,000 --> 00:04:47,000
+It uses zero for the Java virtual machine can check the whole module dependency graph from application
+
+54
+00:04:47,000 --> 00:04:52,000
+module and four one one zero virtual machine starts up.
+
+55
+00:04:52,000 --> 00:05:00,000
+If any required models are not found at startup, the Java Virtual Machine reports is a missing module
+
+56
+00:05:00,000 --> 00:05:03,000
+and shuts down before Java nine Mason class.
+
+57
+00:05:04,000 --> 00:05:11,000
+Just from a Mason Jar file, for example, would not be detected until the application actually tried
+
+58
+00:05:11,000 --> 00:05:12,000
+to use Zoom Mason class.
+
+59
+00:05:13,000 --> 00:05:20,000
+This would happen sometime at runtime dependent on one's application tried to use the missing class.
+
+60
+00:05:20,000 --> 00:05:28,000
+Having missing modules reported at application startup time is a big advantage compared to its runtime
+
+61
+00:05:28,000 --> 00:05:37,000
+when trying to use Zoom's Mojo Jar plus strong encapsulation zip packages in the module are accessible
+
+62
+00:05:37,000 --> 00:05:41,000
+to OSM modules only use the module explicitly exports them.
+
+63
+00:05:42,000 --> 00:05:51,000
+Even then, another module can't use those packages unless it explicitly states that it requires as
+
+64
+00:05:51,000 --> 00:05:53,000
+other modules capabilities.
+
+65
+00:05:53,000 --> 00:05:59,000
+This improves platform security because fewer classes accessible to potential attackers.
+
+66
+00:06:00,000 --> 00:06:06,000
+You may find that considering modularity helps you come up with cleaner, more logical designs.
+
+67
+00:06:07,000 --> 00:06:15,000
+Scalable Java Platform Robust is a Java platform was a monolith consisting of a massive number of packages,
+
+68
+00:06:16,000 --> 00:06:20,000
+making it challenging to develop, maintain and evolve.
+
+69
+00:06:20,000 --> 00:06:22,000
+It couldn't be easily subset.
+
+70
+00:06:23,000 --> 00:06:27,000
+The platform is now one of the rise into ninety five modules.
+
+71
+00:06:28,000 --> 00:06:30,000
+This number might change as Java evolves.
+
+72
+00:06:31,000 --> 00:06:38,000
+You can create custom rom coms consisting of only modules you need for your apps was devices you are
+
+73
+00:06:38,000 --> 00:06:39,000
+targeting.
+
+74
+00:06:39,000 --> 00:06:46,000
+For example, if a device doesn't support graphical user interfaces, you could create a runtime that
+
+75
+00:06:46,000 --> 00:06:47,000
+doesn't include xG.
+
+76
+00:06:47,000 --> 00:06:56,000
+UI modules significantly reduces your runtime size before Java nine and the Java Platform Module system.
+
+77
+00:06:56,000 --> 00:07:03,000
+You would have had to package all of the Java platform APIs with your job application because there
+
+78
+00:07:03,000 --> 00:07:06,000
+was no official way of reliable checking.
+
+79
+00:07:06,000 --> 00:07:09,000
+What crosses your Java application use?
+
+80
+00:07:10,000 --> 00:07:16,000
+Since the job platform API eyes have grown quite large over the years, your application will get the
+
+81
+00:07:16,000 --> 00:07:23,000
+large amount of Java classes included in its distribution, many of which your application would probably
+
+82
+00:07:23,000 --> 00:07:24,000
+not be using.
+
+83
+00:07:25,000 --> 00:07:32,000
+Greater platform integrity Before Java Non, it was possible to use many classes in the platform as
+
+84
+00:07:32,000 --> 00:07:35,000
+it were not meant for use by and apps.
+
+85
+00:07:35,000 --> 00:07:43,000
+Classes with strong encapsulation zones and channel API are truly encapsulated and hidden from apps
+
+86
+00:07:43,000 --> 00:07:45,000
+using the platform.
+
+87
+00:07:45,000 --> 00:07:51,000
+This can make migrating legacy code the Modularized Java non problematic.
+
+88
+00:07:51,000 --> 00:07:59,000
+If your code depends on internal APIs, then use glossies make up the key from distributable big, then
+
+89
+00:07:59,000 --> 00:08:00,000
+it needs to be.
+
+90
+00:08:01,000 --> 00:08:08,000
+This can be a problem on small devices like mobile phones, Raspberry Pi, etc. was a Java platform
+
+91
+00:08:08,000 --> 00:08:09,000
+modular system.
+
+92
+00:08:10,000 --> 00:08:16,000
+You can now package your application was always a module of the Java Platform API that your application
+
+93
+00:08:16,000 --> 00:08:18,000
+is actually using.
+
+94
+00:08:18,000 --> 00:08:21,000
+This will result in small application distribution.
+
+95
+00:08:21,000 --> 00:08:24,000
+Both improve performance.
+
+96
+00:08:25,000 --> 00:08:29,000
+Gem uses various optimization techniques to improve application performance.
+
+97
+00:08:30,000 --> 00:08:38,000
+GSR 376 indicates that these techniques are more effective when it's known in advance.
+
+98
+00:08:39,000 --> 00:08:46,000
+Word types are located only in specific modules, and this was a great improvement for Java as a platform.
+
+99
+00:08:47,000 --> 00:08:53,000
+Nowadays, questions about modules among many questions during different Oracle certifications.
+
+100
+00:08:54,000 --> 00:08:57,000
+Let's talk now about different modules types.
+
+101
+00:08:57,000 --> 00:09:03,000
+There are four types of modules in the new model system system modules.
+
+102
+00:09:03,000 --> 00:09:07,000
+These other modules listed when we run Java.
+
+103
+00:09:07,000 --> 00:09:14,000
+These modules Command Z, includes a Java Sea and JDK modules application modules.
+
+104
+00:09:15,000 --> 00:09:22,000
+These models are what we usually want to build when we decide to use modules z unnamed and defined as
+
+105
+00:09:22,000 --> 00:09:28,000
+a compile module info class file included in the assembled jar.
+
+106
+00:09:28,000 --> 00:09:37,000
+Today, we are going to create our own module info file and see all examples automatic modules.
+
+107
+00:09:37,000 --> 00:09:43,000
+We can include unofficial modules by an existing jar files to the module pass.
+
+108
+00:09:43,000 --> 00:09:47,000
+The name of the module will be derived from the name of the jar.
+
+109
+00:09:48,000 --> 00:09:58,000
+Automatic modules will have full access to every OSM module loaded by pass name tomorrow when a class
+
+110
+00:09:58,000 --> 00:10:01,000
+or jar is loaded into the class bus.
+
+111
+00:10:01,000 --> 00:10:03,000
+But no, the module bus.
+
+112
+00:10:03,000 --> 00:10:06,000
+It's automatically added to the unnamed model.
+
+113
+00:10:07,000 --> 00:10:14,000
+It's a catch all model to maintain backwards compatibility with previously written Java code.
+
+114
+00:10:14,000 --> 00:10:19,000
+The unnamed, more new concept is similar to the default package.
+
+115
+00:10:19,000 --> 00:10:26,000
+Therefore, it is not considered a real model but can be viewed as a default module.
+
+116
+00:10:26,000 --> 00:10:33,000
+We can create multi-modal projects comprised of a main application and several library modules.
+
+117
+00:10:33,000 --> 00:10:39,000
+We have to be careful, though, because we can only have one module per jar file.
+
+118
+00:10:40,000 --> 00:10:46,000
+Let's see now what module descriptor is and what are the different directives that might be used in
+
+119
+00:10:46,000 --> 00:10:53,000
+the module if a Java file, as we have discussed already, a module must provide a module descriptor
+
+120
+00:10:53,000 --> 00:11:00,000
+metadata that specifies the modules, dependencies, zip packages the model makes available to other
+
+121
+00:11:00,000 --> 00:11:07,000
+modules and more, and module descriptor is a compiled version of the module declaration that's defined
+
+122
+00:11:07,000 --> 00:11:09,000
+in the file name module.
+
+123
+00:11:09,000 --> 00:11:16,000
+Info jowar and the first scene that we need to do is to create a file was named Module Info and with
+
+124
+00:11:16,000 --> 00:11:17,000
+Java extension.
+
+125
+00:11:18,000 --> 00:11:22,000
+This file should be located in the source code directory.
+
+126
+00:11:23,000 --> 00:11:31,000
+Each module declaration begins with the keyword module, followed by a unique module name and the module
+
+127
+00:11:31,000 --> 00:11:35,000
+body enclosed in races like you see in that example.
+
+128
+00:11:35,000 --> 00:11:40,000
+In general, module name follows the same naming rules as Java packages.
+
+129
+00:11:41,000 --> 00:11:48,000
+However, you should not use underscores any module names or package names, class and these massive
+
+130
+00:11:48,000 --> 00:11:56,000
+names, variable names, etc. from Gemini and Forward because Java wants to use underscore as reserved
+
+131
+00:11:56,000 --> 00:11:58,000
+and easy to in the future.
+
+132
+00:11:58,000 --> 00:12:05,000
+It is recommended to name a Java module is the same as the name of the root Java package contained in
+
+133
+00:12:05,000 --> 00:12:06,000
+the module.
+
+134
+00:12:06,000 --> 00:12:14,000
+If that is possible, because some of this might contain multiple packages is a module declarations,
+
+135
+00:12:14,000 --> 00:12:22,000
+but it can be empty or may contain various module directives, including the requis experts provide
+
+136
+00:12:22,000 --> 00:12:27,000
+space, etc. We are going to discuss each of these in a few minutes.
+
+137
+00:12:27,000 --> 00:12:35,000
+As you'll see later, components and module declaration create is a model descriptor, which is stored
+
+138
+00:12:35,000 --> 00:12:40,000
+in the file named Module Info, plus the Modules folder.
+
+139
+00:12:40,000 --> 00:12:48,000
+On this slide, I will briefly introduce each module directive Zacchaeus only in module declarations
+
+140
+00:12:48,000 --> 00:12:53,000
+and may be used as identifiers anywhere else in your code.
+
+141
+00:12:53,000 --> 00:12:56,000
+Let's learn now directives.
+
+142
+00:12:56,000 --> 00:13:00,000
+The first directives that we are given to them is requires.
+
+143
+00:13:00,000 --> 00:13:06,000
+This module directive allows us to declare module dependencies, for example.
+
+144
+00:13:06,000 --> 00:13:13,000
+In this case, my module has both a runtime and the compile time dependency on some module that you
+
+145
+00:13:13,000 --> 00:13:15,000
+should refer by module name.
+
+146
+00:13:16,000 --> 00:13:20,000
+Each module must explicitly state its dependencies.
+
+147
+00:13:20,000 --> 00:13:30,000
+When Module eight requires Model B, Module A is set to read Module B and Module B is spread by Module
+
+148
+00:13:30,000 --> 00:13:37,000
+A, the specified dependency on another module user requires and all public Typekit.
+
+149
+00:13:37,000 --> 00:13:43,000
+Experts from a dependency are accessible by our module when we use this directive.
+
+150
+00:13:43,000 --> 00:13:50,000
+Another important mention here is that it is not allowed to have separate dependencies between modules.
+
+151
+00:13:50,000 --> 00:14:00,000
+In other words, if Module eight requires Module B, Module B can also require module a z module dependency
+
+152
+00:14:00,000 --> 00:14:06,000
+graph must be an acyclic graph and thus a directive is a quasi static.
+
+153
+00:14:06,000 --> 00:14:09,000
+We might write a lot of functions that pretty.
+
+154
+00:14:10,000 --> 00:14:18,000
+Our internal state one another to log in module is present, but not every consumer of our level will
+
+155
+00:14:18,000 --> 00:14:24,000
+want this functionality, and they don't want to include an extra log in library.
+
+156
+00:14:24,000 --> 00:14:28,000
+In this case, we want to use an optional dependency.
+
+157
+00:14:29,000 --> 00:14:35,000
+By using the request setting directive, we create a compile time only dependency.
+
+158
+00:14:35,000 --> 00:14:38,000
+Now let's learn transitive directive.
+
+159
+00:14:39,000 --> 00:14:45,000
+Imagine that we want to use third party library, and that library in turn has other dependencies.
+
+160
+00:14:46,000 --> 00:14:54,000
+How we can make sure that any module that we are dependent on will bring its own dependencies to work
+
+161
+00:14:54,000 --> 00:14:54,000
+properly.
+
+162
+00:14:55,000 --> 00:15:03,000
+We can force any downstream consumers also to read our required dependencies, which requires transitive.
+
+163
+00:15:03,000 --> 00:15:11,000
+Attractive, let's review exports DirecTV Now, as you already could understand, is a strong encapsulation
+
+164
+00:15:11,000 --> 00:15:18,000
+was one of the main goal when Java Platform Module System has been introduced by default, and Model
+
+165
+00:15:18,000 --> 00:15:22,000
+doesn't expose any of its API to other modules.
+
+166
+00:15:23,000 --> 00:15:31,000
+Our code is significantly more secure if we don't expose our API to external users.
+
+167
+00:15:31,000 --> 00:15:38,000
+But what if we created API that it should be used by different modules and we need to explicitly make
+
+168
+00:15:38,000 --> 00:15:40,000
+it available for everyone?
+
+169
+00:15:40,000 --> 00:15:46,000
+We use the experts directive to expose all public members of the named package.
+
+170
+00:15:47,000 --> 00:15:55,000
+Please note that only the least the package itself is experts now support packages of the experts package
+
+171
+00:15:56,000 --> 00:15:56,000
+experts.
+
+172
+00:15:57,000 --> 00:16:06,000
+That means that even this package, in my example, contains a package named You Zens Akombe.
+
+173
+00:16:06,000 --> 00:16:11,000
+My package name util package is not exported.
+
+174
+00:16:11,000 --> 00:16:16,000
+Just because of parent package is to export the SAP package.
+
+175
+00:16:16,000 --> 00:16:24,000
+Also, we must declare it explicitly in the module descriptor, and the one module is a singular package
+
+176
+00:16:24,000 --> 00:16:29,000
+can only be exported by a single Java module at one time.
+
+177
+00:16:29,000 --> 00:16:37,000
+In other words, you can't have two or more and more and use that export the same package in use at
+
+178
+00:16:37,000 --> 00:16:38,000
+the same time.
+
+179
+00:16:39,000 --> 00:16:46,000
+The Java Virtual Machine will come clean startup if you do having two modules export.
+
+180
+00:16:46,000 --> 00:16:55,000
+The same package is also sometimes referred to as a split package by split package is meant that the
+
+181
+00:16:55,000 --> 00:17:01,000
+total content classes of the package is split between the multiple modules.
+
+182
+00:17:02,000 --> 00:17:03,000
+This is not allowed.
+
+183
+00:17:04,000 --> 00:17:13,000
+In case we want to limit access to our API and expose it only to some packages XL, we have to use experts
+
+184
+00:17:13,000 --> 00:17:17,000
+to direct it similar to the experts directive.
+
+185
+00:17:17,000 --> 00:17:25,000
+We declare a package as experts, but we also list which models we are allowing to import this package
+
+186
+00:17:25,000 --> 00:17:26,000
+as it requires.
+
+187
+00:17:27,000 --> 00:17:36,000
+And here's how it looks like the next directive is users now use this Model Directive Force, a service
+
+188
+00:17:36,000 --> 00:17:44,000
+used by this module, making the model a service consumer, a service services, an object of loss that
+
+189
+00:17:44,000 --> 00:17:45,000
+implements the interface.
+
+190
+00:17:45,000 --> 00:17:49,000
+So extensive apps are specified in the users directive.
+
+191
+00:17:50,000 --> 00:17:55,000
+With this in mind, the services our model consumes with a users directive.
+
+192
+00:17:56,000 --> 00:17:58,000
+No, just the last name we use.
+
+193
+00:17:58,000 --> 00:18:06,000
+This is the interface for apps, loss of the service, the on the implementation class, because service
+
+194
+00:18:06,000 --> 00:18:12,000
+in this context means and implementation of a specific interface or apps a gloss that can be consumed
+
+195
+00:18:12,000 --> 00:18:14,000
+by OSI classes.
+
+196
+00:18:14,000 --> 00:18:21,000
+But what is the difference between uses and requires the wrappers we might require and more uses?
+
+197
+00:18:21,000 --> 00:18:29,000
+It provides a service we want to consume, but that service implements an interface from one of its
+
+198
+00:18:29,000 --> 00:18:36,000
+transitive dependencies instead of forcing our module to require all transitive dependencies.
+
+199
+00:18:36,000 --> 00:18:43,000
+Just in case we use the uses, Directive two adds the required interface to the module.
+
+200
+00:18:43,000 --> 00:18:44,000
+POS is a career.
+
+201
+00:18:45,000 --> 00:18:52,000
+We have discussed directives that consumes the services, but this also means that we have modules that
+
+202
+00:18:52,000 --> 00:19:00,000
+provides services so a module can also be a service providers that other modules can consume, and we
+
+203
+00:19:00,000 --> 00:19:04,000
+can ensure this voice provides with direction.
+
+204
+00:19:05,000 --> 00:19:12,000
+We should write provides key words first and specifies the interface or abstract class name of our service
+
+205
+00:19:13,000 --> 00:19:14,000
+is Let's see.
+
+206
+00:19:14,000 --> 00:19:21,000
+What we have to do is to specify what specific implementation of our service we are going to provide
+
+207
+00:19:22,000 --> 00:19:24,000
+was a help with directing.
+
+208
+00:19:25,000 --> 00:19:29,000
+You provide the implementation class name that isn't implements.
+
+209
+00:19:29,000 --> 00:19:33,000
+The interface or extents is an abstract class.
+
+210
+00:19:34,000 --> 00:19:40,000
+The next important declarations that I'd like to show you opens and opens to.
+
+211
+00:19:41,000 --> 00:19:44,000
+Let's learn this before December nine.
+
+212
+00:19:44,000 --> 00:19:53,000
+Reflection could be used to learn about all types in the package and all members of it time even its
+
+213
+00:19:53,000 --> 00:19:58,000
+private members, was the one that allows this capability on not.
+
+214
+00:19:59,000 --> 00:20:04,000
+Thus, nothing was truly encapsulated like we have discussed already.
+
+215
+00:20:05,000 --> 00:20:12,000
+The key motivation of the module system is strong, and cancellation by default and died in the module
+
+216
+00:20:12,000 --> 00:20:19,000
+is not accessible to OSM modules unless it's a public type and you export its package.
+
+217
+00:20:20,000 --> 00:20:26,000
+You expose all the packages you want to expose with Gemini.
+
+218
+00:20:26,000 --> 00:20:28,000
+This also applies to reflection.
+
+219
+00:20:29,000 --> 00:20:36,000
+For example, we can allow runtime only access to a package, so directive opened.
+
+220
+00:20:36,000 --> 00:20:44,000
+Some package indicates that a specific package is public types and then nested public and protected
+
+221
+00:20:44,000 --> 00:20:49,000
+types accessible to code in other modules at runtime only.
+
+222
+00:20:49,000 --> 00:20:59,000
+Also, all the types in the specified package and all of the types members are accessible via reflection.
+
+223
+00:20:59,000 --> 00:21:08,000
+Another example We can allow runtime only access the package by specific modules and opens to Model
+
+224
+00:21:08,000 --> 00:21:08,000
+Directive.
+
+225
+00:21:09,000 --> 00:21:18,000
+Like, for example, open package name to some list of modules indicates that specific packages, public
+
+226
+00:21:18,000 --> 00:21:26,000
+types and then nascent public and protected types are accessible to code in the list of modules at runtime
+
+227
+00:21:26,000 --> 00:21:27,000
+only.
+
+228
+00:21:27,000 --> 00:21:35,000
+All of the types in the specified package and all of the types members are accessible via reflection
+
+229
+00:21:35,000 --> 00:21:37,000
+to court in the specified modules.
+
+230
+00:21:38,000 --> 00:21:45,000
+We have discussed already that one of the main goals of modules is strong encapsulation, and I believe
+
+231
+00:21:45,000 --> 00:21:50,000
+that you watched the previous lesson and you're pretty familiar with reflection by this moment already.
+
+232
+00:21:51,000 --> 00:21:58,000
+So you can understand that before June nine, it was possible to use a reflection to examine every type
+
+233
+00:21:59,000 --> 00:22:02,000
+and the member in the package, even the private ones.
+
+234
+00:22:03,000 --> 00:22:04,000
+Was through.
+
+235
+00:22:04,000 --> 00:22:11,000
+Really encapsulated, which can open up all kinds of problems for developers of the libraries because
+
+236
+00:22:11,000 --> 00:22:13,000
+Java nine enforce a strong encapsulation.
+
+237
+00:22:14,000 --> 00:22:21,000
+We have to explicitly grant permission for OSM modules to reflect on our classes if we want to continue
+
+238
+00:22:21,000 --> 00:22:28,000
+to allow full reflection as older versions of Java did, we can simply opens entire modules by using
+
+239
+00:22:28,000 --> 00:22:32,000
+open direct before module name like you see on the slide.
+
+240
+00:22:33,000 --> 00:22:35,000
+Does it make sense so far?
+
+241
+00:22:35,000 --> 00:22:42,000
+And please always remember these in case you have any questions, please post them below this video
+
+242
+00:22:42,000 --> 00:22:45,000
+and I will be happy to answer those.
+
+243
+00:22:45,000 --> 00:22:51,000
+We have just learned directives that we can use in our modules in profile.
+
+244
+00:22:51,000 --> 00:22:55,000
+The next step would be to learn how to build our modules.
+
+245
+00:22:56,000 --> 00:22:59,000
+And before I show you examples of how to do that.
+
+246
+00:23:00,000 --> 00:23:01,000
+Let me explain.
+
+247
+00:23:01,000 --> 00:23:08,000
+Different command line options that we can use when we build Java modules, even despite the fact that
+
+248
+00:23:08,000 --> 00:23:15,000
+later in our course, we are going to learn such views as Randall and May one and zero when you have
+
+249
+00:23:15,000 --> 00:23:18,000
+support for building modules in Java.
+
+250
+00:23:18,000 --> 00:23:22,000
+It's still valuable to know how to use modules.
+
+251
+00:23:22,000 --> 00:23:28,000
+System forms a common plan will be used as a common line for our full example.
+
+252
+00:23:28,000 --> 00:23:36,000
+I'm going to show you in a few minutes to help solidify how the entire system works in our minds.
+
+253
+00:23:37,000 --> 00:23:38,000
+Module Pass.
+
+254
+00:23:38,000 --> 00:23:42,000
+We use a module pass option to specify the module for us.
+
+255
+00:23:42,000 --> 00:23:49,000
+This is a list of one on one directories that contain our modules athletes.
+
+256
+00:23:49,000 --> 00:23:57,000
+Instead of relying on the module declaration file, we can use the command line equivalent of the requires
+
+257
+00:23:57,000 --> 00:23:59,000
+directors and experts.
+
+258
+00:24:00,000 --> 00:24:09,000
+Common Line replacement for the X Plus DirecTV and Opens replaces the open clause in the module declaration
+
+259
+00:24:09,000 --> 00:24:16,000
+file adds modules adds is a list of modules into the default set of modules.
+
+260
+00:24:16,000 --> 00:24:24,000
+These modules creates a list of all modules and their version strings by each module.
+
+261
+00:24:24,000 --> 00:24:27,000
+Add or overwrite classes in modules.
+
+262
+00:24:28,000 --> 00:24:38,000
+Illegal acts was values is permit over or do not use a relaxed encapsulation by showing a single global
+
+263
+00:24:38,000 --> 00:24:43,000
+warning shows rewarding or fails with errors.
+
+264
+00:24:43,000 --> 00:24:45,000
+The default is permit.
+
+265
+00:24:46,000 --> 00:24:49,000
+Finally, we are done with the mini series piece.
+
+266
+00:24:49,000 --> 00:24:53,000
+Let's continue learning modules with examples now.
+
+267
+00:24:53,000 --> 00:24:57,000
+This would be our Hello World modular application.
+
+268
+00:24:57,000 --> 00:25:04,000
+Thus, it would all be super complicated because the main goal right now is to make you understand key
+
+269
+00:25:04,000 --> 00:25:07,000
+principles of modular application.
+
+270
+00:25:08,000 --> 00:25:15,000
+The rest of the synths will be super easy to understand if you learned how everything works on the hood.
+
+271
+00:25:15,000 --> 00:25:23,000
+So first of all, I want to say that for the sake of the demo, I created separate multi module project.
+
+272
+00:25:23,000 --> 00:25:27,000
+I will share with you a link to it in attachments to this lesson.
+
+273
+00:25:28,000 --> 00:25:32,000
+I have Food Project folder and I created the Modules folder.
+
+274
+00:25:33,000 --> 00:25:38,000
+Apparently, this folder will contain different modules of my app.
+
+275
+00:25:38,000 --> 00:25:43,000
+It is full of some main modules as a root source package.
+
+276
+00:25:43,000 --> 00:25:49,000
+For example, it was a top level package of the module is compatibles greetings.
+
+277
+00:25:49,000 --> 00:25:52,000
+Then I named the module in the same way.
+
+278
+00:25:53,000 --> 00:25:55,000
+Note this is a full stops.
+
+279
+00:25:55,000 --> 00:25:57,000
+These are modular root directory name.
+
+280
+00:25:58,000 --> 00:26:07,000
+Z's full stops need to be easier because part of the module name Zen not to be interpreted as subdirectory
+
+281
+00:26:07,000 --> 00:26:08,000
+POS dividers.
+
+282
+00:26:09,000 --> 00:26:09,000
+Is it the.
+
+283
+00:26:10,000 --> 00:26:13,000
+As you can see, I have two models here.
+
+284
+00:26:13,000 --> 00:26:16,000
+Let me start from greeting Swan.
+
+285
+00:26:16,000 --> 00:26:24,000
+It contains loss was named greetings and static mass insight that brings hello world to console.
+
+286
+00:26:25,000 --> 00:26:28,000
+Each model should have Model E for file.
+
+287
+00:26:29,000 --> 00:26:32,000
+Let's look at the model descriptor of this model.
+
+288
+00:26:32,000 --> 00:26:34,000
+On the top, you can see model name.
+
+289
+00:26:35,000 --> 00:26:42,000
+Basically, model name and name of the model for this should match and be expert package from this model.
+
+290
+00:26:42,000 --> 00:26:46,000
+Experts directive is used was package name.
+
+291
+00:26:47,000 --> 00:26:53,000
+Now creates a second model is the name of my second module is Compatibles App.
+
+292
+00:26:53,000 --> 00:26:56,000
+This is the main module that uses greetings module.
+
+293
+00:26:57,000 --> 00:27:04,000
+It has only one class was the main message where we use greetings class to invoke say hello mass pay
+
+294
+00:27:04,000 --> 00:27:05,000
+attention.
+
+295
+00:27:05,000 --> 00:27:11,000
+We also have the import statement here to import greetings class from another package.
+
+296
+00:27:11,000 --> 00:27:14,000
+This module also has module descriptor.
+
+297
+00:27:15,000 --> 00:27:16,000
+Let's look at it.
+
+298
+00:27:16,000 --> 00:27:24,000
+Here we can see that this module requires my greetings module, and this is all of this agree because
+
+299
+00:27:24,000 --> 00:27:27,000
+we are using class from greetings module in this one.
+
+300
+00:27:28,000 --> 00:27:36,000
+Then the stand dependencies between these two modules, if he isn't great, if no, please press pause
+
+301
+00:27:36,000 --> 00:27:40,000
+for a minute and think about it one more time.
+
+302
+00:27:40,000 --> 00:27:48,000
+The next step that we need to do this to compile our models specially for that, I create a script that
+
+303
+00:27:48,000 --> 00:27:50,000
+will compile all sources.
+
+304
+00:27:50,000 --> 00:28:00,000
+It is located in the root directory and it is called Build this sage I use Linux shall come here, so
+
+305
+00:28:00,000 --> 00:28:07,000
+pay attention to your transit script, either on Linux platforms or from Bosch on your Windows machine
+
+306
+00:28:07,000 --> 00:28:12,000
+and do not use Windows Common Line to run this script.
+
+307
+00:28:12,000 --> 00:28:14,000
+You know what Java commands?
+
+308
+00:28:15,000 --> 00:28:16,000
+This is our Java compiler.
+
+309
+00:28:17,000 --> 00:28:24,000
+After that, I pass the name of the output directly to specify where I want to put the compiled classes.
+
+310
+00:28:25,000 --> 00:28:29,000
+The next thing I do, I need to pass module source plus option.
+
+311
+00:28:30,000 --> 00:28:33,000
+This is different from the one I shared before.
+
+312
+00:28:33,000 --> 00:28:40,000
+If you remember the interview module courses on a separate slot, there is a difference between module
+
+313
+00:28:40,000 --> 00:28:43,000
+costs and module source boss.
+
+314
+00:28:43,000 --> 00:28:51,000
+The component needs a distinction between the code it used to compile in module source, boss and location
+
+315
+00:28:51,000 --> 00:28:55,000
+of compiled dependencies and libraries.
+
+316
+00:28:55,000 --> 00:28:58,000
+Module boss does it make more sense now?
+
+317
+00:28:59,000 --> 00:29:02,000
+I was here name of my folder with modules.
+
+318
+00:29:03,000 --> 00:29:09,000
+After that, I used Show Command to find old files with Java Extension in Modules folder.
+
+319
+00:29:10,000 --> 00:29:13,000
+Once my modular app is compiled, I can run it.
+
+320
+00:29:14,000 --> 00:29:16,000
+I have another script for this.
+
+321
+00:29:16,000 --> 00:29:18,000
+Is it a school run app or sage?
+
+322
+00:29:19,000 --> 00:29:21,000
+Let's look at it in this script.
+
+323
+00:29:21,000 --> 00:29:25,000
+You also see program that is familiar to you, Java.
+
+324
+00:29:26,000 --> 00:29:28,000
+I am going to start Java Virtual Machine.
+
+325
+00:29:29,000 --> 00:29:37,000
+I use option module POS to puzzle the reference to the compiled modules and after completion, all of
+
+326
+00:29:37,000 --> 00:29:41,000
+them are stored in target output directory.
+
+327
+00:29:41,000 --> 00:29:49,000
+You can see that all files here have class extension and even module info file is compiled into class
+
+328
+00:29:49,000 --> 00:29:49,000
+file.
+
+329
+00:29:50,000 --> 00:29:58,000
+Zen I specifies that most of the class it contains main message zip past consists of module name and
+
+330
+00:29:58,000 --> 00:29:59,000
+full class name.
+
+331
+00:30:00,000 --> 00:30:08,000
+So in this particular example, Compatibles Rules app is the model name and call it Bus App.
+
+332
+00:30:08,000 --> 00:30:11,000
+App is a full class name.
+
+333
+00:30:11,000 --> 00:30:12,000
+Is this clear?
+
+334
+00:30:13,000 --> 00:30:17,000
+For the sake of the demo, I opened it March inside eclipse.
+
+335
+00:30:17,000 --> 00:30:27,000
+I run build S.H. script first, and after that I run run apps, script and hindcast so we can see Hello
+
+336
+00:30:27,000 --> 00:30:29,000
+World from the application.
+
+337
+00:30:29,000 --> 00:30:30,000
+Can you see this?
+
+338
+00:30:30,000 --> 00:30:34,000
+Congratulations to you with your first modular application.
+
+339
+00:30:35,000 --> 00:30:40,000
+One more small comment here was the moment of recording this video.
+
+340
+00:30:40,000 --> 00:30:45,000
+There is no single and proper way of using Eclipse to run multi-modal application.
+
+341
+00:30:46,000 --> 00:30:51,000
+There might be some additional steps to configure multimodal application in eclipse.
+
+342
+00:30:52,000 --> 00:30:59,000
+That's why, even on your work, most likely you would use common client to build and to run your complex
+
+343
+00:30:59,000 --> 00:31:02,000
+enterprise application for the sake of convenience.
+
+344
+00:31:03,000 --> 00:31:10,000
+You still can work in eclipse, but do you need to be prepared that sometimes you will see more errors?
+
+345
+00:31:10,000 --> 00:31:17,000
+Is unusual because sometimes it is hard to conceive of all dependencies, not in the app, but in the
+
+346
+00:31:17,000 --> 00:31:25,000
+creep's itself in order Eclipse would understand the clearly dependencies between all modules.
+
+347
+00:31:25,000 --> 00:31:33,000
+Here's an example you can import two modules as separate projects and work in Java editor was Java files.
+
+348
+00:31:34,000 --> 00:31:42,000
+But in app module, you may see error because Eclipse can't see dependency on another module.
+
+349
+00:31:42,000 --> 00:31:49,000
+Since technically fruit loops, this is a separate project, and the groups allows only one module info
+
+350
+00:31:49,000 --> 00:31:51,000
+file per project.
+
+351
+00:31:51,000 --> 00:31:53,000
+In order to remove the error.
+
+352
+00:31:53,000 --> 00:31:57,000
+Sometimes you may need to configure dependencies manually.
+
+353
+00:31:57,000 --> 00:32:04,000
+If Eclipse didn't manage to configure everything automatically, for example, in my app module, I
+
+354
+00:32:04,000 --> 00:32:11,000
+open built up submenu, configure builds bus and here on library staff.
+
+355
+00:32:12,000 --> 00:32:16,000
+On the Module POS, I select Add Class Folder.
+
+356
+00:32:16,000 --> 00:32:24,000
+Here I put checkbox next to the modules that they need in this one, namely Reding's module and press,
+
+357
+00:32:24,000 --> 00:32:24,000
+OK.
+
+358
+00:32:25,000 --> 00:32:32,000
+Now you wouldn't see any errors in the clips, but in case you have multiple modules and not all of
+
+359
+00:32:32,000 --> 00:32:34,000
+them, I configure it automatically.
+
+360
+00:32:34,000 --> 00:32:41,000
+This might take time during the configuration of your project very first time after these configuration
+
+361
+00:32:41,000 --> 00:32:42,000
+steps.
+
+362
+00:32:42,000 --> 00:32:44,000
+You may run even from Eclipse.
+
+363
+00:32:45,000 --> 00:32:51,000
+Can you see this great since you have near Z simple syncs already?
+
+364
+00:32:51,000 --> 00:32:56,000
+Let me show you how to add the service to our modular application.
+
+365
+00:32:56,000 --> 00:33:04,000
+In my Goulding's module, I declare an interface was name service status log that contains only one
+
+366
+00:33:04,000 --> 00:33:07,000
+massive print service that is slow.
+
+367
+00:33:07,000 --> 00:33:10,000
+I have implementation of this interface.
+
+368
+00:33:10,000 --> 00:33:17,000
+Is it the school default service status slogan for the sake of our demo and just brings text to console?
+
+369
+00:33:18,000 --> 00:33:26,000
+Now, in my model info file, I need to declare that this module provides such service was a complete
+
+370
+00:33:26,000 --> 00:33:27,000
+implementation.
+
+371
+00:33:27,000 --> 00:33:30,000
+I use provides service directive for.
+
+372
+00:33:30,000 --> 00:33:37,000
+This is the next logical step would be to consumes this service in my app module.
+
+373
+00:33:37,000 --> 00:33:44,000
+I use uses directly for that and specify full class name of the interface.
+
+374
+00:33:45,000 --> 00:33:52,000
+After that, in App G+ with the help of Service Loader from January to package I can load my service.
+
+375
+00:33:52,000 --> 00:33:57,000
+I use load mass and quasi loss of the services that I need.
+
+376
+00:33:57,000 --> 00:34:00,000
+Service loader is a terrible time.
+
+377
+00:34:01,000 --> 00:34:07,000
+That's why it has iterate mass app that allows me to get a reference to the first service load.
+
+378
+00:34:07,000 --> 00:34:12,000
+The object in the sequence handles a reference to the object.
+
+379
+00:34:12,000 --> 00:34:15,000
+I can call print service that is massive.
+
+380
+00:34:16,000 --> 00:34:24,000
+Let's now use our new brush to compile new sources one more time and run our app in so you can see that
+
+381
+00:34:24,000 --> 00:34:27,000
+we successfully managed to invoke service message.
+
+382
+00:34:28,000 --> 00:34:31,000
+That's all what I wanted to share with you in this lesson.
+
+383
+00:34:32,000 --> 00:34:35,000
+Let's recap what we have learned in this lesson.
+
+384
+00:34:36,000 --> 00:34:40,000
+In the lesson we have learned what general models are all seeing.
+
+385
+00:34:40,000 --> 00:34:45,000
+Those are goals that we want to achieve and that that captures images.
+
+386
+00:34:45,000 --> 00:34:47,000
+376.
+
+387
+00:34:47,000 --> 00:34:53,000
+We have learned different more of those types of after that revealed details.
+
+388
+00:34:53,000 --> 00:35:01,000
+Different command line options to work was more use and on real example, you saw how to create, build
+
+389
+00:35:01,000 --> 00:35:03,000
+and run modular application.
+
+390
+00:35:04,000 --> 00:35:06,000
+Together, we can simulate eclipse.
+
+391
+00:35:06,000 --> 00:35:13,000
+The work was modular application form I.D. and the zenith of the lesson I explained to you how to provide
+
+392
+00:35:13,000 --> 00:35:16,000
+and consume service in different modules.
+
+393
+00:35:17,000 --> 00:35:19,000
+Thanks a lot for your attention.
+
+394
+00:35:19,000 --> 00:35:22,000
+Have a great day and see you in the next lesson.
+

32 - Java Platform Module System Modules in Java & Migration of Java Apps/001 Source-code-examples-from-the-lesson-Modular-Project.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/java-modules

32 - Java Platform Module System Modules in Java & Migration of Java Apps/002 -Example-Migration-Guide-by-Oracle.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://docs.oracle.com/en/java/javase/12/migrate/index.html#JSMIG-GUID-C25E2B1D-6C24-4403-8540-CFEA875B994A

32 - Java Platform Module System Modules in Java & Migration of Java Apps/002 Migration of Java Apps Example of migration to a modular application_en.srt

@@ -0,0 +1,1524 @@
+1
+00:00:06,000 --> 00:00:11,000
+Hello, distance in Prius lesson, we have learned what modules are in decay?
+
+2
+00:00:11,000 --> 00:00:14,000
+We also created our first modular application.
+
+3
+00:00:14,000 --> 00:00:21,000
+In case you skipped the previous lesson, please make sure you watched it because in this lesson, we'll
+
+4
+00:00:21,000 --> 00:00:23,000
+keep talking about modules.
+
+5
+00:00:24,000 --> 00:00:28,000
+But this time will not create our module application from scratch.
+
+6
+00:00:28,000 --> 00:00:35,000
+But instead, we'll focus our attention on the questions of migration of Nano Modular Java application
+
+7
+00:00:35,000 --> 00:00:37,000
+to modular Java application.
+
+8
+00:00:37,000 --> 00:00:44,000
+Also, this lesson will be interesting for architects who are in charge of Java migration and responsible
+
+9
+00:00:44,000 --> 00:00:47,000
+for making decisions and planning next migration steps.
+
+10
+00:00:48,000 --> 00:00:53,000
+You need to be aware about issues and solutions that we are going to discuss in this lesson.
+
+11
+00:00:54,000 --> 00:01:00,000
+This is a super important topic, especially if your organization made a decision to migrate from Java
+
+12
+00:01:00,000 --> 00:01:07,000
+eight to NAS, a long term support version like Java Plans that includes support of modules.
+
+13
+00:01:07,000 --> 00:01:14,000
+And also, this is super important in case you decide to pass Oracle Java certifications, because some
+
+14
+00:01:14,000 --> 00:01:22,000
+of the Oracle certifications include questions about migration to modular application, including top
+
+15
+00:01:22,000 --> 00:01:29,000
+down and bottom up migration, and Split Ajala Agile Associates application into modules for migration.
+
+16
+00:01:30,000 --> 00:01:36,000
+We'll start our lesson from learning and understanding of general algorithm for migration of our court
+
+17
+00:01:36,000 --> 00:01:41,000
+to the new environment, including migration to the new version of Dedicate.
+
+18
+00:01:41,000 --> 00:01:47,000
+Special focus today will be the migration of application to modular architecture.
+
+19
+00:01:47,000 --> 00:01:54,000
+I will explain in one Java Class Dependency Analyzer tool is and what Java deprecated API is.
+
+20
+00:01:54,000 --> 00:01:57,000
+Current tool is also we're going to learn today.
+
+21
+00:01:57,000 --> 00:02:04,000
+Different migration strategies will review Bottom-Up and top-down migration strategies that start our
+
+22
+00:02:04,000 --> 00:02:05,000
+lesson.
+
+23
+00:02:06,000 --> 00:02:13,000
+And before I start diving in details, let's come up with steps and migration algorithm first, the
+
+24
+00:02:13,000 --> 00:02:15,000
+step number zero and super important one.
+
+25
+00:02:16,000 --> 00:02:21,000
+If you great internet, not sure that you would find this advice anywhere, but exactly as you said,
+
+26
+00:02:21,000 --> 00:02:23,000
+was help make them a great deal.
+
+27
+00:02:23,000 --> 00:02:29,000
+Worse software products two different versions and environments before any movements were scored that
+
+28
+00:02:29,000 --> 00:02:36,000
+potentially may impact the way our program works, no matter whether this is refactoring or migrating
+
+29
+00:02:36,000 --> 00:02:41,000
+and in what may impact or change code and the way how it is executed.
+
+30
+00:02:42,000 --> 00:02:45,000
+Make sure that you have for libel suit of tests on different levels.
+
+31
+00:02:46,000 --> 00:02:51,000
+The general recommendation here would be to automate as much as possible.
+
+32
+00:02:51,000 --> 00:02:57,000
+Some of my clients say to me that this automation is a huge investments and they have dedicated manual
+
+33
+00:02:57,000 --> 00:03:04,000
+regression time and cost wise, easy to understand the point you were talking about short periods of
+
+34
+00:03:04,000 --> 00:03:07,000
+time and a not complex project.
+
+35
+00:03:07,000 --> 00:03:11,000
+But I also saw projects where regression takes months.
+
+36
+00:03:11,000 --> 00:03:13,000
+Nowadays, probably it is crazy.
+
+37
+00:03:13,000 --> 00:03:19,000
+Amount of times it will add this software product to survive in the current environment, where your
+
+38
+00:03:19,000 --> 00:03:26,000
+competitors are releasing new features each week or two weeks and your product only has regression for
+
+39
+00:03:26,000 --> 00:03:26,000
+one months.
+
+40
+00:03:27,000 --> 00:03:27,000
+Definitely.
+
+41
+00:03:27,000 --> 00:03:30,000
+Is there a different areas and domains?
+
+42
+00:03:30,000 --> 00:03:31,000
+Some of them more competitive?
+
+43
+00:03:32,000 --> 00:03:33,000
+Some of them less.
+
+44
+00:03:33,000 --> 00:03:35,000
+But I am sure you understood my point.
+
+45
+00:03:36,000 --> 00:03:42,000
+So when my clients send me about not having enough resources on the creation of automation test and
+
+46
+00:03:42,000 --> 00:03:48,000
+framework that includes small tests, use regression tests, etc., I'm asking a simple question.
+
+47
+00:03:49,000 --> 00:03:55,000
+I am sure that in this case, you have enough resources and needs to halt any migrations.
+
+48
+00:03:56,000 --> 00:04:02,000
+Probably it is better to put resources into product development, marketing to the market, find investments
+
+49
+00:04:02,000 --> 00:04:09,000
+and come to the point where we have enough resources to scale and grow because otherwise we are not
+
+50
+00:04:09,000 --> 00:04:12,000
+doing any migration just to do migration.
+
+51
+00:04:12,000 --> 00:04:20,000
+We need to identify purposes of the migration and be sure that our migration brings some value and it
+
+52
+00:04:20,000 --> 00:04:21,000
+is needed.
+
+53
+00:04:21,000 --> 00:04:27,000
+And if it is needed, we're happy to accept all imports and provide everything what is necessary to
+
+54
+00:04:27,000 --> 00:04:28,000
+make this happen.
+
+55
+00:04:29,000 --> 00:04:31,000
+Here's where the first principle comes from.
+
+56
+00:04:32,000 --> 00:04:39,000
+We need to identify goals of our migration and measures to stay specific and objective.
+
+57
+00:04:39,000 --> 00:04:46,000
+What we are trying to achieve by performance, better security, better code design in order to be able
+
+58
+00:04:46,000 --> 00:04:48,000
+to scale application faster.
+
+59
+00:04:49,000 --> 00:04:53,000
+This is super important and once goal is defined.
+
+60
+00:04:53,000 --> 00:04:56,000
+Make measurements of the current system.
+
+61
+00:04:56,000 --> 00:04:58,000
+You need to have something and other.
+
+62
+00:04:58,000 --> 00:05:00,000
+You can say communication has been successful.
+
+63
+00:05:00,000 --> 00:05:06,000
+Often, migration trends are the goals were achieved because at the end of the day, we never the a
+
+64
+00:05:06,000 --> 00:05:09,000
+factor on migration just for fun.
+
+65
+00:05:09,000 --> 00:05:12,000
+We do it to get advantage of measurable benefits.
+
+66
+00:05:13,000 --> 00:05:14,000
+Never forget about this.
+
+67
+00:05:15,000 --> 00:05:21,000
+Let's agree it's within the scope of this particular demo will hold migration to another long term support
+
+68
+00:05:21,000 --> 00:05:28,000
+Java release in order to achieve better structure in order to simplify introducing of new features,
+
+69
+00:05:29,000 --> 00:05:35,000
+improving court architecture to make each release predictable and reduce impact of introducing new changes
+
+70
+00:05:35,000 --> 00:05:37,000
+on already released codes.
+
+71
+00:05:38,000 --> 00:05:39,000
+Improved security.
+
+72
+00:05:39,000 --> 00:05:46,000
+We are achieving better encapsulation of components, greater platform integrity, improved performance.
+
+73
+00:05:47,000 --> 00:05:52,000
+These are goals of Java platform Model S system and in case you missed the previous lesson.
+
+74
+00:05:52,000 --> 00:06:00,000
+Please watch it because we discussed goals and benefits of modules in detail in previous lesson, and
+
+75
+00:06:00,000 --> 00:06:03,000
+we agreed to migrate our app to the modular architecture.
+
+76
+00:06:04,000 --> 00:06:06,000
+Let's review the following steps for this.
+
+77
+00:06:07,000 --> 00:06:14,000
+The next thing that we need to do is to download the updated JDK version Java Platform Modular System
+
+78
+00:06:14,000 --> 00:06:17,000
+finally was introduced in Java version nine.
+
+79
+00:06:18,000 --> 00:06:25,000
+But as we discussed in the first lesson about JDK, I would recommend you to use long term support Java
+
+80
+00:06:25,000 --> 00:06:25,000
+versions.
+
+81
+00:06:26,000 --> 00:06:28,000
+Nowadays, we have two long term support versions.
+
+82
+00:06:29,000 --> 00:06:35,000
+They are eight and 11 considering that we want to migrate our app to have modular application.
+
+83
+00:06:36,000 --> 00:06:39,000
+Most likely, we would opt for Java version 11.
+
+84
+00:06:39,000 --> 00:06:43,000
+But you also can opt for Java version nine if you wish.
+
+85
+00:06:44,000 --> 00:06:46,000
+Wrong application was near adjudicate.
+
+86
+00:06:46,000 --> 00:06:48,000
+This is also important step.
+
+87
+00:06:48,000 --> 00:06:54,000
+Java ensures backwards compatibility, but still, there might be some changes.
+
+88
+00:06:55,000 --> 00:07:02,000
+For example, if you used some options for garbage collector, pay attention that, for example, indicate,
+
+89
+00:07:02,000 --> 00:07:04,000
+well, some of them removed.
+
+90
+00:07:05,000 --> 00:07:11,000
+That's why, even despite Java guarantees backwards compatibility, it is never redundant to compile
+
+91
+00:07:12,000 --> 00:07:14,000
+and run your app with new adjudication.
+
+92
+00:07:15,000 --> 00:07:20,000
+Also, this might be important to ensure compatibility was a by your libraries.
+
+93
+00:07:20,000 --> 00:07:26,000
+So the main goal is to run your app on the use adjudicate mission and to deal with this task.
+
+94
+00:07:26,000 --> 00:07:32,000
+You need to be aware about new features in Japanese that you want to use for immigration.
+
+95
+00:07:32,000 --> 00:07:35,000
+This can be easily found on the official websites.
+
+96
+00:07:36,000 --> 00:07:40,000
+The first step would be to update third party dependencies if needed.
+
+97
+00:07:40,000 --> 00:07:47,000
+So we need to make sure that your app was all external dependencies may be compiled, built and started
+
+98
+00:07:47,000 --> 00:07:51,000
+successfully Ranji DApps against your project.
+
+99
+00:07:52,000 --> 00:07:53,000
+Enthusiasm for familiar with J.
+
+100
+00:07:53,000 --> 00:07:55,000
+DApps and don't know what it is.
+
+101
+00:07:56,000 --> 00:07:57,000
+Let me quickly explain.
+
+102
+00:07:58,000 --> 00:08:05,000
+Basically, this is a tool that is present in JDK to identify dependencies between classes, modules,
+
+103
+00:08:05,000 --> 00:08:07,000
+packages in your app.
+
+104
+00:08:07,000 --> 00:08:12,000
+It is a common line to runs a Java Class Dependency Analyzer tool.
+
+105
+00:08:13,000 --> 00:08:20,000
+It processes Java bytecode, meaning the class files all the jars that contains them and analyzes the
+
+106
+00:08:20,000 --> 00:08:23,000
+statically declared dependencies between the classes.
+
+107
+00:08:23,000 --> 00:08:30,000
+The results can be filtered in various ways and can be aggregated to package or jar level.
+
+108
+00:08:31,000 --> 00:08:34,000
+Knapp's is also fully aware of the module system.
+
+109
+00:08:34,000 --> 00:08:41,000
+This is super important and useful for you to understand before you plan and immigration, and before
+
+110
+00:08:41,000 --> 00:08:47,000
+you make any final decision about your modules and packages structured a little bit later.
+
+111
+00:08:47,000 --> 00:08:54,000
+In this lesson, I am going to show you how to work with Jade DApps program Ramji that are scrum against
+
+112
+00:08:54,000 --> 00:08:55,000
+your project.
+
+113
+00:08:55,000 --> 00:08:59,000
+If you're not familiar with this, though, let me quickly explain what it is.
+
+114
+00:09:00,000 --> 00:09:07,000
+This tool is a static analysis tools its concept jar file or some other aggregation of class files for
+
+115
+00:09:07,000 --> 00:09:10,000
+usages of deprecated API elements.
+
+116
+00:09:10,000 --> 00:09:18,000
+When you upgrade to the new version, you might be interested in this information to to update your
+
+117
+00:09:18,000 --> 00:09:19,000
+code accordingly.
+
+118
+00:09:19,000 --> 00:09:26,000
+Do not accumulate dependencies on deprecated classes and masses a little bit later today on the real
+
+119
+00:09:26,000 --> 00:09:30,000
+example, I'm going to show you how to apply this to now.
+
+120
+00:09:30,000 --> 00:09:36,000
+After all these steps, we're safe to proceed with the next steps on this stage.
+
+121
+00:09:36,000 --> 00:09:43,000
+Having all necessary input information, we are ready to make a decision and plan the duration we need
+
+122
+00:09:43,000 --> 00:09:45,000
+to select the migration strategy.
+
+123
+00:09:45,000 --> 00:09:47,000
+Today, we'll discuss a few of them.
+
+124
+00:09:48,000 --> 00:09:53,000
+Once you select migration strategy and plan migration steps, we're going to proceed with migration
+
+125
+00:09:53,000 --> 00:09:54,000
+execution.
+
+126
+00:09:55,000 --> 00:10:02,000
+Usually, Oracle and community release migration guides for each new version that contains important
+
+127
+00:10:02,000 --> 00:10:06,000
+information that you need to consider during the migration of your app.
+
+128
+00:10:06,000 --> 00:10:10,000
+One of such goods, I will leave in attachments to the lesson.
+
+129
+00:10:10,000 --> 00:10:17,000
+But you can easily find similar guides for other versions, and each migration should be followed by
+
+130
+00:10:17,000 --> 00:10:18,000
+regression testing.
+
+131
+00:10:18,000 --> 00:10:25,000
+We already discussed that even before starting doing steps like this, we need to make sure that we
+
+132
+00:10:25,000 --> 00:10:32,000
+have reliable sort of tests that will allow us to confirm that at least nothing is broken and migration
+
+133
+00:10:32,000 --> 00:10:33,000
+goals are achieved.
+
+134
+00:10:34,000 --> 00:10:39,000
+After that, we are ready to proceed with a step where you can apply measurements that you did before
+
+135
+00:10:39,000 --> 00:10:42,000
+migration to verify region of migration goals.
+
+136
+00:10:43,000 --> 00:10:49,000
+For example, if the goal was to improve performance, measure performance of your app after migration
+
+137
+00:10:49,000 --> 00:10:52,000
+and if performance become even worse.
+
+138
+00:10:52,000 --> 00:10:55,000
+The question is was immigration was successful?
+
+139
+00:10:55,000 --> 00:10:57,000
+I don't think so.
+
+140
+00:10:57,000 --> 00:11:02,000
+That means is that some steps still need to be done and planned.
+
+141
+00:11:02,000 --> 00:11:08,000
+This migration should be adjusted to include additional steps to reach the goal of migration.
+
+142
+00:11:08,000 --> 00:11:09,000
+Does it make sense?
+
+143
+00:11:10,000 --> 00:11:14,000
+So now, like the reviews it, I'll Google one more time.
+
+144
+00:11:15,000 --> 00:11:16,000
+Press pause if needed.
+
+145
+00:11:17,000 --> 00:11:24,000
+And once you are sure about each step and the sequence of actions we are glad to proceed is a step number
+
+146
+00:11:24,000 --> 00:11:25,000
+zero.
+
+147
+00:11:25,000 --> 00:11:26,000
+I have separate course for that.
+
+148
+00:11:27,000 --> 00:11:30,000
+You can check my course got and test during development.
+
+149
+00:11:30,000 --> 00:11:33,000
+I elaborated a lot on this topic.
+
+150
+00:11:33,000 --> 00:11:36,000
+Step number one is up to you and your organization.
+
+151
+00:11:37,000 --> 00:11:42,000
+You should identify goals of migration internally, and I wouldn't be able to help you with that.
+
+152
+00:11:43,000 --> 00:11:45,000
+Do not forget to perform any measurements.
+
+153
+00:11:45,000 --> 00:11:51,000
+How long was a goal to compare these before immigration and after migration?
+
+154
+00:11:52,000 --> 00:11:57,000
+Regarding the loading of the latest duplicate version, I believe if you already watching this lesson,
+
+155
+00:11:58,000 --> 00:12:03,000
+you are smart and mature enough to download Oracle JDK or open JDK.
+
+156
+00:12:04,000 --> 00:12:07,000
+After that, you need to run your project with new JDK.
+
+157
+00:12:07,000 --> 00:12:13,000
+I'm sure you will be able to those that want the same as updates and third party dependencies too,
+
+158
+00:12:14,000 --> 00:12:18,000
+and with the next step, probably let me help you with that one.
+
+159
+00:12:19,000 --> 00:12:26,000
+Let me explain to you more about the app's program, how to use it and show this on live demo.
+
+160
+00:12:27,000 --> 00:12:33,000
+So as we have discussed, GDP is a Java dependency analysis tool, probably the first questions that
+
+161
+00:12:33,000 --> 00:12:39,000
+students ask me is where they can get the depth and the words they should download.
+
+162
+00:12:39,000 --> 00:12:45,000
+I want to say that you don't need to worry about that if you have dedicated, download it on your PC.
+
+163
+00:12:46,000 --> 00:12:47,000
+This program is already is.
+
+164
+00:12:47,000 --> 00:12:55,000
+They're waiting for you in bin folder since Java version eight will work with this tool directly from
+
+165
+00:12:55,000 --> 00:12:56,000
+Command Prompt.
+
+166
+00:12:57,000 --> 00:13:03,000
+So make sure that you JDK pass configure it properly and that Jane Daps Version Command returns your
+
+167
+00:13:04,000 --> 00:13:05,000
+result in command line.
+
+168
+00:13:06,000 --> 00:13:11,000
+Let me show you a quick them in order you could understand how to work with this still.
+
+169
+00:13:12,000 --> 00:13:15,000
+This told me on the last group of classes.
+
+170
+00:13:15,000 --> 00:13:21,000
+Let me show you two examples now in the first example, I will show you how to analyze old fashioned
+
+171
+00:13:21,000 --> 00:13:25,000
+clean Java project as a simple project we are going to use.
+
+172
+00:13:25,000 --> 00:13:32,000
+My Java project was examples, the ones that are used to demonstrate different topics to students of
+
+173
+00:13:32,000 --> 00:13:32,000
+mine.
+
+174
+00:13:33,000 --> 00:13:40,000
+And then the second example will analyze more single modular project that doesn't have too much dependencies
+
+175
+00:13:40,000 --> 00:13:44,000
+between different packages and modules in case you have a general project.
+
+176
+00:13:44,000 --> 00:13:51,000
+The first thing that you need to do is to aggregate all components resources in one folder miserably
+
+177
+00:13:51,000 --> 00:14:01,000
+Jr. Archive in separate lessons were learned such build tools and maven granule, et cetera, that those
+
+178
+00:14:01,000 --> 00:14:08,000
+in charge of building your project, creating some deployable pieces like jars or walls, and now a
+
+179
+00:14:08,000 --> 00:14:14,000
+specific case would need to generate just by our cells in the clips.
+
+180
+00:14:14,000 --> 00:14:21,000
+I can easily do this by mouse, right click on the project, find them experts option and select the
+
+181
+00:14:21,000 --> 00:14:21,000
+jar.
+
+182
+00:14:21,000 --> 00:14:23,000
+File some options here.
+
+183
+00:14:23,000 --> 00:14:32,000
+Now we need to specify jar pots and place where archive will be located and generated zen numerous of
+
+184
+00:14:32,000 --> 00:14:32,000
+other options.
+
+185
+00:14:33,000 --> 00:14:37,000
+Majority of them are so describing I want a stop on those.
+
+186
+00:14:37,000 --> 00:14:44,000
+But even in case you have some questions, let me know in comments below this video and I will be happy
+
+187
+00:14:44,000 --> 00:14:44,000
+to answer.
+
+188
+00:14:45,000 --> 00:14:47,000
+Now one, we have jar file.
+
+189
+00:14:47,000 --> 00:14:49,000
+We are ready to analyze it.
+
+190
+00:14:49,000 --> 00:14:56,000
+I open it bush terminal in this folder and now executes my script in this directory.
+
+191
+00:14:57,000 --> 00:15:02,000
+Commands that I'm going to execute is stored in a common dirt file.
+
+192
+00:15:03,000 --> 00:15:08,000
+I store the script on the Zagat index so that you could investigate it later.
+
+193
+00:15:08,000 --> 00:15:12,000
+Let me open this script and I will explain what is the reason here.
+
+194
+00:15:13,000 --> 00:15:16,000
+This is actually to invoke Java dependency analysis.
+
+195
+00:15:17,000 --> 00:15:25,000
+That output is a command line option to specify a destination directory for the file output, not file
+
+196
+00:15:25,000 --> 00:15:32,000
+content is simple tags that can be copied and pasted into the online editor, for example, or other
+
+197
+00:15:32,000 --> 00:15:39,000
+editors to generate graphs that visualizes dependencies will generate one in the middle.
+
+198
+00:15:40,000 --> 00:15:44,000
+You can see that they use Dot after dot output option.
+
+199
+00:15:44,000 --> 00:15:51,000
+If you are familiar with this character, then you already know that Daughtery first is a current directory.
+
+200
+00:15:52,000 --> 00:15:59,000
+So this means is a dirt file will be generated in the current directory, whereas this command will
+
+201
+00:15:59,000 --> 00:16:00,000
+be executed.
+
+202
+00:16:01,000 --> 00:16:03,000
+The next option is recursive.
+
+203
+00:16:03,000 --> 00:16:11,000
+This option recursive the traverses or runtime dependencies plus force option specifies directory was
+
+204
+00:16:11,000 --> 00:16:19,000
+ClassPass, including external dependencies in our particular cases, with few external dependencies
+
+205
+00:16:19,000 --> 00:16:20,000
+on different lessons.
+
+206
+00:16:20,000 --> 00:16:24,000
+And I don't know that these jurors into my downloads folder.
+
+207
+00:16:25,000 --> 00:16:32,000
+That's why I also included those here, and the last program argument is just to analyze.
+
+208
+00:16:33,000 --> 00:16:35,000
+Basically, that is the ones that we built.
+
+209
+00:16:36,000 --> 00:16:42,000
+It contains all classes from all packages of my training project that's executed the script.
+
+210
+00:16:43,000 --> 00:16:48,000
+I wrote the name of the script to console and press enter.
+
+211
+00:16:49,000 --> 00:16:56,000
+It takes some time to analyze dependencies, but finally, not file is generated in the current directory.
+
+212
+00:16:57,000 --> 00:17:02,000
+Let's open it, and you can see that the content of this file is just text.
+
+213
+00:17:03,000 --> 00:17:05,000
+It contains some specific structure.
+
+214
+00:17:06,000 --> 00:17:13,000
+You can see dependency of each package on another package, probably when you have session load of packages.
+
+215
+00:17:14,000 --> 00:17:21,000
+It is even better to use this text representation to analyze this data and think about structuring new
+
+216
+00:17:21,000 --> 00:17:21,000
+modules.
+
+217
+00:17:22,000 --> 00:17:27,000
+But still, if you want to visualize it, let's use special tools for that.
+
+218
+00:17:27,000 --> 00:17:31,000
+We can find online tools to visualize our dependencies.
+
+219
+00:17:32,000 --> 00:17:36,000
+For example, we can use just one of those I'm talking about.
+
+220
+00:17:36,000 --> 00:17:45,000
+Map Graph is just Scorpion's based content of the file based here and press generate graphs button.
+
+221
+00:17:45,000 --> 00:17:50,000
+That was easy, but you can see how much gross dependencies we are.
+
+222
+00:17:51,000 --> 00:17:51,000
+Definitely.
+
+223
+00:17:51,000 --> 00:17:57,000
+There is a lot of work here, considering this is a project and a lot of different topics.
+
+224
+00:17:57,000 --> 00:18:04,000
+Some of them very often reuses some common glosses or packages, and that's why we have something like
+
+225
+00:18:04,000 --> 00:18:04,000
+this.
+
+226
+00:18:05,000 --> 00:18:08,000
+You can spend time after the lesson and used to get this.
+
+227
+00:18:09,000 --> 00:18:11,000
+I added these files in to get this.
+
+228
+00:18:12,000 --> 00:18:16,000
+So you will be able to find those in the directory of the project.
+
+229
+00:18:17,000 --> 00:18:23,000
+Most likely, if you would, any great all project that doesn't have more destruction, you would see
+
+230
+00:18:23,000 --> 00:18:24,000
+something like this.
+
+231
+00:18:25,000 --> 00:18:26,000
+Or even worse.
+
+232
+00:18:26,000 --> 00:18:29,000
+Well, most likely you will see worse.
+
+233
+00:18:30,000 --> 00:18:31,000
+Sorry, but this is true.
+
+234
+00:18:32,000 --> 00:18:39,000
+OK, let's move on, and now I'd like to show you how to work with this, though, if you would like
+
+235
+00:18:39,000 --> 00:18:41,000
+to analyze modular application.
+
+236
+00:18:41,000 --> 00:18:46,000
+And you remember, is it a previous lesson of the creative modular application?
+
+237
+00:18:46,000 --> 00:18:49,000
+Let's analyze dependencies for that app.
+
+238
+00:18:50,000 --> 00:18:56,000
+The idea is similar, but instead of Java, you can pass a reference to the director with your modules
+
+239
+00:18:56,000 --> 00:18:59,000
+so you already can make a conclusion.
+
+240
+00:18:59,000 --> 00:19:06,000
+ZG Depths Program has separate group of command line options for modular and non modular applications.
+
+241
+00:19:07,000 --> 00:19:12,000
+These are common ones that they want to execute is also stored in shell script.
+
+242
+00:19:12,000 --> 00:19:16,000
+Let me open the file and we'll discuss what is written here.
+
+243
+00:19:17,000 --> 00:19:22,000
+Also to execute shell script in the other directory, I open terminal.
+
+244
+00:19:23,000 --> 00:19:30,000
+As you can see, I use Module First Command Line option and pauses a reference to the directory where
+
+245
+00:19:30,000 --> 00:19:32,000
+all my module is located.
+
+246
+00:19:33,000 --> 00:19:39,000
+Another option is that modules to add modules to zero set for analysis.
+
+247
+00:19:39,000 --> 00:19:46,000
+I use custom to add all modules in the directory as the last option here is the list is pretty familiar
+
+248
+00:19:46,000 --> 00:19:47,000
+to you.
+
+249
+00:19:47,000 --> 00:19:49,000
+This is for the output.
+
+250
+00:19:49,000 --> 00:19:55,000
+Let's execute this script in the terminal and we have generated summary file.
+
+251
+00:19:55,000 --> 00:20:02,000
+Let's copy content from here and let me paste this content on the website to generate the graph.
+
+252
+00:20:03,000 --> 00:20:09,000
+As you can see, code I think moves at depends on coal.
+
+253
+00:20:09,000 --> 00:20:16,000
+I think moves greetings module and Moses and the pass on Java based module.
+
+254
+00:20:16,000 --> 00:20:18,000
+Is it clear for you?
+
+255
+00:20:18,000 --> 00:20:23,000
+Press a pause for a minute and sync one more time about this live demo.
+
+256
+00:20:24,000 --> 00:20:24,000
+Thank you.
+
+257
+00:20:24,000 --> 00:20:26,000
+Samsung is still not clear for you.
+
+258
+00:20:27,000 --> 00:20:32,000
+Please do not hesitate to pose your question below this video, and I will be happy to answer.
+
+259
+00:20:34,000 --> 00:20:40,000
+On the screen, you can find common long options that you may use with great depths on the slide, you
+
+260
+00:20:40,000 --> 00:20:42,000
+can find possible options.
+
+261
+00:20:43,000 --> 00:20:45,000
+Module dependency analysis options.
+
+262
+00:20:46,000 --> 00:20:48,000
+Options to filter dependencies.
+
+263
+00:20:48,000 --> 00:20:51,000
+Options to filter closest to be analyzed.
+
+264
+00:20:51,000 --> 00:20:54,000
+And as you can see, there are a lot of them.
+
+265
+00:20:54,000 --> 00:20:58,000
+Probably it doesn't make any sense to me holding them off each option.
+
+266
+00:20:58,000 --> 00:21:03,000
+I believe you understood the main principle, and so I would demo was few options.
+
+267
+00:21:03,000 --> 00:21:06,000
+You can just play with other options if you want.
+
+268
+00:21:07,000 --> 00:21:11,000
+Feel free to pause the Ouija if you want to read all comments on the slide.
+
+269
+00:21:12,000 --> 00:21:14,000
+OK, let's proceed.
+
+270
+00:21:15,000 --> 00:21:21,000
+The next thing that I am going to demo you is depressed, can't program, you have a deprecated API
+
+271
+00:21:21,000 --> 00:21:25,000
+kind of tool is a common line tool to scan for users.
+
+272
+00:21:25,000 --> 00:21:29,000
+So deprecated API elements of given Java class files.
+
+273
+00:21:29,000 --> 00:21:38,000
+Input glosses can be given as a bosnich to a class file and directory or jar file, the same as G Deps
+
+274
+00:21:38,000 --> 00:21:44,000
+G Deeper Scan also has been included in genica installation since adjudicate.
+
+275
+00:21:44,000 --> 00:21:48,000
+That means you can find that in bin folder of Dedicate.
+
+276
+00:21:48,000 --> 00:21:54,000
+And if you configure Java POS properly, you can access it from command line.
+
+277
+00:21:55,000 --> 00:22:01,000
+I'm going to show you example, Wisconsin, of my learning project, I put Judy Proskauer in Shell script.
+
+278
+00:22:02,000 --> 00:22:08,000
+The simplest way how to use this command is to invoke it and pass journal names that we would like to
+
+279
+00:22:08,000 --> 00:22:09,000
+scan.
+
+280
+00:22:09,000 --> 00:22:12,000
+I want to execute this script and get the bus.
+
+281
+00:22:12,000 --> 00:22:21,000
+And again, it takes some time because Project has a lot of files and it is done on the top.
+
+282
+00:22:21,000 --> 00:22:24,000
+You can see notifications in which classes are used.
+
+283
+00:22:24,000 --> 00:22:32,000
+Deprecated masses Knowing this information, you can just check deprecated masses, usually in documentation
+
+284
+00:22:32,000 --> 00:22:38,000
+is deprecated mass that it is specified which other mass that you should use instead.
+
+285
+00:22:38,000 --> 00:22:39,000
+That is simple.
+
+286
+00:22:40,000 --> 00:22:40,000
+I agree.
+
+287
+00:22:41,000 --> 00:22:45,000
+And this command also has few important command line options.
+
+288
+00:22:45,000 --> 00:22:47,000
+Definitely Zionism's MS engine.
+
+289
+00:22:47,000 --> 00:22:55,000
+That program has but still something for you, at least to be aware of response if you want to explore
+
+290
+00:22:55,000 --> 00:22:56,000
+all these in details.
+
+291
+00:22:57,000 --> 00:22:59,000
+And if you're OK, I will continue.
+
+292
+00:23:00,000 --> 00:23:03,000
+Now, let's review immigration strategies.
+
+293
+00:23:03,000 --> 00:23:09,000
+We will cover case when a regional application is based on gender versions that is less than juvenile
+
+294
+00:23:10,000 --> 00:23:17,000
+or it is Java nine or higher, but the modular approach wasn't originally implemented since the use
+
+295
+00:23:17,000 --> 00:23:19,000
+of this mechanism is fully optional.
+
+296
+00:23:20,000 --> 00:23:26,000
+M. relearned tools and went through the step where we did the line, which modules draft files are present
+
+297
+00:23:26,000 --> 00:23:30,000
+in application and what dependencies exist between them.
+
+298
+00:23:30,000 --> 00:23:37,000
+Also, another way to do that besides such automated tools of static code analysis as DApps is through
+
+299
+00:23:37,000 --> 00:23:42,000
+an Iraqi eagle diagram, whereas these dependencies are represented in their way.
+
+300
+00:23:43,000 --> 00:23:49,000
+This will help give an overview of the components of the application and of each of them, and in which
+
+301
+00:23:49,000 --> 00:23:51,000
+orders it can be migrated.
+
+302
+00:23:51,000 --> 00:23:57,000
+Identifying those who will not be able to adopt temporally or definitively.
+
+303
+00:23:58,000 --> 00:24:04,000
+The later case can be given, for example, insert various libraries that have stopped offering support,
+
+304
+00:24:04,000 --> 00:24:06,000
+and that will hardly become modules.
+
+305
+00:24:07,000 --> 00:24:12,000
+There are two different migration mechanisms that responds to different initial situations.
+
+306
+00:24:13,000 --> 00:24:20,000
+To illustrate the process in each of them, let's imagine the next scenario we plan to migrate an application
+
+307
+00:24:20,000 --> 00:24:25,000
+that consists of three jars representing the different layers of the application.
+
+308
+00:24:26,000 --> 00:24:32,000
+They are application services and utilize the diagrams that you can see on the screen.
+
+309
+00:24:32,000 --> 00:24:35,000
+Now shows the dependencies between these lists.
+
+310
+00:24:36,000 --> 00:24:42,000
+Where application depends on services and the tiers and services depends on the utils only.
+
+311
+00:24:42,000 --> 00:24:45,000
+Let's review Bottom-Up migration first.
+
+312
+00:24:45,000 --> 00:24:52,000
+In this strategy, initially, all jar files that are part of the application will be located at its
+
+313
+00:24:52,000 --> 00:24:53,000
+ClassPass.
+
+314
+00:24:54,000 --> 00:24:56,000
+All of them can be migrated one by one.
+
+315
+00:24:56,000 --> 00:24:58,000
+Does the module POS?
+
+316
+00:24:58,000 --> 00:25:01,000
+To do this, we need to follow describes steps.
+
+317
+00:25:02,000 --> 00:25:08,000
+The first thing that we need to do is to choose a project package or layer was the lowest position in
+
+318
+00:25:08,000 --> 00:25:09,000
+dependencies.
+
+319
+00:25:09,000 --> 00:25:12,000
+Iraqi yet has not yet been migrated to module.
+
+320
+00:25:13,000 --> 00:25:17,000
+That means to select the project that has less dependencies.
+
+321
+00:25:17,000 --> 00:25:20,000
+In our case, this is your deals there.
+
+322
+00:25:20,000 --> 00:25:26,000
+After that and the module info Java file to the project, it will be needed to.
+
+323
+00:25:26,000 --> 00:25:33,000
+Ads are quite explicit statements to make current module packages available to Iraqi Higher Level Modules
+
+324
+00:25:33,000 --> 00:25:41,000
+Moves Integrated Project as a named module from application's class bus to its module bus ensure that
+
+325
+00:25:41,000 --> 00:25:43,000
+all not yet migrated.
+
+326
+00:25:43,000 --> 00:25:48,000
+The modules remain as unnamed modules in application's class bus.
+
+327
+00:25:48,000 --> 00:25:52,000
+What is unnamed modules were discussed in previous lesson.
+
+328
+00:25:52,000 --> 00:26:00,000
+One of the learned modules types please refer to the previous lesson through use that, if needed after
+
+329
+00:26:00,000 --> 00:26:07,000
+we did all this is this seems it remains to do is to repeat this process was the next lowest level packages
+
+330
+00:26:08,000 --> 00:26:10,000
+list of projects in the Iraqi.
+
+331
+00:26:10,000 --> 00:26:15,000
+That is not migrated yet, and we are progressing in the bottom direction.
+
+332
+00:26:15,000 --> 00:26:23,000
+Can you understand now why this strategy is called bottom up when this approach works the best and when
+
+333
+00:26:23,000 --> 00:26:24,000
+we need to apply?
+
+334
+00:26:24,000 --> 00:26:27,000
+The bottom up migration strategy was the best one.
+
+335
+00:26:27,000 --> 00:26:33,000
+We have the ability to modify any jar that has not yet been converted to module.
+
+336
+00:26:33,000 --> 00:26:41,000
+It makes easier as a migration of the project's packages was a whole layers that are at the top of the
+
+337
+00:26:41,000 --> 00:26:47,000
+dependency diagram and encourages care in what is exposed to other modules.
+
+338
+00:26:48,000 --> 00:26:54,000
+The modules of the lower levels of the Iraqi will be found in the module costs without access to the
+
+339
+00:26:54,000 --> 00:26:56,000
+packages of unnamed modules.
+
+340
+00:26:57,000 --> 00:27:03,000
+While these unnamed modules that have not been migrated and allocated in the class, ClassPass will
+
+341
+00:27:03,000 --> 00:27:09,000
+be able to access zip packages located in both class and module bus.
+
+342
+00:27:10,000 --> 00:27:11,000
+Does it make sense so far?
+
+343
+00:27:13,000 --> 00:27:19,000
+And now is immigration strategy would be top down in this strategy, initially, all jar files that
+
+344
+00:27:19,000 --> 00:27:25,000
+are part of the application will be located at its model bus, so all non-immigrant its projects are
+
+345
+00:27:25,000 --> 00:27:27,000
+treated as automatic modules.
+
+346
+00:27:28,000 --> 00:27:31,000
+Greatest lesson I current or what automatic modules are.
+
+347
+00:27:32,000 --> 00:27:36,000
+So please make sure you watch the previous lesson about modules.
+
+348
+00:27:36,000 --> 00:27:44,000
+If you forget, this is example when I didn't use modular approach since it is optional in this case,
+
+349
+00:27:44,000 --> 00:27:47,000
+it is recommended to frozen next steps.
+
+350
+00:27:47,000 --> 00:27:54,000
+The first thing to do is to choose a high level project and the dependencies Iraqi that has not yet
+
+351
+00:27:54,000 --> 00:27:56,000
+been integrated the module.
+
+352
+00:27:56,000 --> 00:28:03,000
+After that, we need to add some module info gel file to the project to transform it from an automatic
+
+353
+00:28:03,000 --> 00:28:05,000
+module to a named module.
+
+354
+00:28:06,000 --> 00:28:12,000
+Also, we shouldn't forget to add necessary expert statements to make current module packages available
+
+355
+00:28:12,000 --> 00:28:20,000
+to other modules and the necessary require statements that makes available OSM modules expose packages
+
+356
+00:28:20,000 --> 00:28:25,000
+to the current one in case of the reference to a module not yet migrated.
+
+357
+00:28:26,000 --> 00:28:29,000
+It should be done through its automatic module name.
+
+358
+00:28:29,000 --> 00:28:36,000
+Once these have been migrated, these references should be changed to Z definitive module names.
+
+359
+00:28:37,000 --> 00:28:41,000
+Repeat this process was the next high level component.
+
+360
+00:28:41,000 --> 00:28:44,000
+Is Iraqi citizens not migrated yet?
+
+361
+00:28:44,000 --> 00:28:49,000
+Then the stunt in which case is top down strategy needs to be applied and robust at best.
+
+362
+00:28:50,000 --> 00:28:55,000
+This strategy is the best when you don't have the possibility of one day on the horizon.
+
+363
+00:28:55,000 --> 00:29:00,000
+All the dependencies of the application was a temporarily or definitively.
+
+364
+00:29:01,000 --> 00:29:06,000
+Also, the lower dependencies of the application have not yet been modularized.
+
+365
+00:29:06,000 --> 00:29:10,000
+The application itself can be converted into morning.
+
+366
+00:29:10,000 --> 00:29:15,000
+Named modules that have already been integrated will be found in the module.
+
+367
+00:29:15,000 --> 00:29:22,000
+Boss was access to the entire code contained in the automatic modules that are also found in module
+
+368
+00:29:22,000 --> 00:29:22,000
+path.
+
+369
+00:29:23,000 --> 00:29:23,000
+Is that clear?
+
+370
+00:29:24,000 --> 00:29:26,000
+And remember another important sync?
+
+371
+00:29:27,000 --> 00:29:31,000
+In all cases, we have to avoid circle of dependencies between modules.
+
+372
+00:29:32,000 --> 00:29:34,000
+That's all what I wanted to share with you in this lesson.
+
+373
+00:29:35,000 --> 00:29:37,000
+Let's recap what we have learned today.
+
+374
+00:29:38,000 --> 00:29:44,000
+After this lesson, you know, general algorithm to follow during the platform, migration to the new
+
+375
+00:29:44,000 --> 00:29:48,000
+environment or in US adjudicate version in particular.
+
+376
+00:29:48,000 --> 00:29:57,000
+I showed you how to use in practice Java Class Dependency Analyzer to also we used how to use Java deprecated
+
+377
+00:29:57,000 --> 00:30:05,000
+API second to review of different migration strategies, namely, we bottom up and top down migration
+
+378
+00:30:05,000 --> 00:30:05,000
+strategies.
+
+379
+00:30:06,000 --> 00:30:11,000
+I hope you'll love this lesson and learned a lot of new useful sinks.
+
+380
+00:30:12,000 --> 00:30:13,000
+Thanks a lot for your attention.
+
+381
+00:30:14,000 --> 00:30:17,000
+Have a great day and see you in the next lesson.
+

32 - Java Platform Module System Modules in Java & Migration of Java Apps/002 Modular-application-example-with-bash-scripts.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/java-modules

32 - Java Platform Module System Modules in Java & Migration of Java Apps/002 Non-modular-application-example-with-bash-scripts.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core

32 - Java Platform Module System Modules in Java & Migration of Java Apps/external-links.txt

@@ -0,0 +1,12 @@
+
+001 Source-code-examples-from-the-lesson-Modular-Project
+https://github.com/AndriiPiatakha/java-modules
+
+002 -Example-Migration-Guide-by-Oracle
+https://docs.oracle.com/en/java/javase/12/migrate/index.html#JSMIG-GUID-C25E2B1D-6C24-4403-8540-CFEA875B994A
+
+002 Non-modular-application-example-with-bash-scripts
+https://github.com/AndriiPiatakha/learnit_java_core
+
+002 Modular-application-example-with-bash-scripts
+https://github.com/AndriiPiatakha/java-modules

33 - Testing for Software Engineers/001 Testing for software engineers Overview_en.srt

@@ -0,0 +1,1308 @@
+1
+00:00:06,000 --> 00:00:06,000
+Hello, dissidents.
+
+2
+00:00:07,000 --> 00:00:10,000
+Today we start an important topic for each software engineer.
+
+3
+00:00:10,000 --> 00:00:15,000
+We are going to learn with your tools and techniques that will help you to make sure that your codes
+
+4
+00:00:15,000 --> 00:00:22,000
+work as expected and to guarantee that each new change didn't break old code already released features.
+
+5
+00:00:22,000 --> 00:00:24,000
+We'll talk about testing today.
+
+6
+00:00:25,000 --> 00:00:28,000
+Don't worry, this is not cause for quality assurance engineers.
+
+7
+00:00:29,000 --> 00:00:31,000
+This is still cause for software developers.
+
+8
+00:00:32,000 --> 00:00:35,000
+You're saying that this is cause for fear automation engineers.
+
+9
+00:00:35,000 --> 00:00:36,000
+You're wrong again.
+
+10
+00:00:37,000 --> 00:00:42,000
+The first thing you have to learn is that software engineers also write tests on regular basis.
+
+11
+00:00:42,000 --> 00:00:47,000
+This is a little bit different kind of tests that usually perform key engineers.
+
+12
+00:00:47,000 --> 00:00:51,000
+And today we're going to learn what testing is after this lesson.
+
+13
+00:00:51,000 --> 00:00:54,000
+You understand why we need to write this.
+
+14
+00:00:54,000 --> 00:00:57,000
+I will elaborate on different functions of testing.
+
+15
+00:00:57,000 --> 00:01:02,000
+You will get a full picture of different types and different levels of testing, and you will understand
+
+16
+00:01:02,000 --> 00:01:04,000
+what testing is.
+
+17
+00:01:04,000 --> 00:01:09,000
+And this lesson will run main principles and rules that should be followed during the testing.
+
+18
+00:01:10,000 --> 00:01:15,000
+By the end of this lesson, you will understand what kind of tests software engineers usually write.
+
+19
+00:01:16,000 --> 00:01:21,000
+Also, you're going to understand the structure of our following lessons and what we will learn first.
+
+20
+00:01:22,000 --> 00:01:26,000
+Let's start and to start with, let's define the goal of testing.
+
+21
+00:01:26,000 --> 00:01:29,000
+How do think why we are so buzzer?
+
+22
+00:01:29,000 --> 00:01:32,000
+It's about testing and what its main goal?
+
+23
+00:01:32,000 --> 00:01:37,000
+Take a second and think to at least a few options and choose the main one, in your opinion.
+
+24
+00:01:38,000 --> 00:01:40,000
+My answer would be the next one.
+
+25
+00:01:40,000 --> 00:01:47,000
+The main goal is to verify that application works as expected, and the key to your success is to make
+
+26
+00:01:47,000 --> 00:01:54,000
+sure that the last part of this sentence, namely, as expected, is defined clearly and the same for
+
+27
+00:01:54,000 --> 00:01:55,000
+you and product owner.
+
+28
+00:01:55,000 --> 00:02:00,000
+In this course, we will learn a few techniques like behavior driven development and acceptance during
+
+29
+00:02:00,000 --> 00:02:06,000
+development that should eliminate the gap in the understanding of the final product between you and
+
+30
+00:02:06,000 --> 00:02:07,000
+product owner.
+
+31
+00:02:08,000 --> 00:02:14,000
+And that is our goal that uses a proper set of tests that will verify various scenarios to make sure
+
+32
+00:02:14,000 --> 00:02:18,000
+that behavior of our application meets expectations of the product owner.
+
+33
+00:02:19,000 --> 00:02:21,000
+In this lesson, I will use product owner.
+
+34
+00:02:21,000 --> 00:02:23,000
+Time to time my senses.
+
+35
+00:02:23,000 --> 00:02:29,000
+I'm a person who is in charge of final acceptance of the software that you and your team will create
+
+36
+00:02:30,000 --> 00:02:30,000
+products on.
+
+37
+00:02:30,000 --> 00:02:35,000
+There can be within your organization or outside of your organization, like it usually happens if you
+
+38
+00:02:35,000 --> 00:02:37,000
+work in outsourcing company.
+
+39
+00:02:37,000 --> 00:02:44,000
+Usually, product owner is closer to the business side in the war, in the commercial side, and how
+
+40
+00:02:44,000 --> 00:02:47,000
+application will satisfy needs of potential customers.
+
+41
+00:02:48,000 --> 00:02:54,000
+Also, product owner worried about features, user experience and all that is related to the application.
+
+42
+00:02:55,000 --> 00:02:57,000
+But Pure is not a technical person.
+
+43
+00:02:58,000 --> 00:03:02,000
+You're going to be able to explain to people that something is not possible because it will require
+
+44
+00:03:02,000 --> 00:03:06,000
+to implement a lot of classes and use a lot of external libraries.
+
+45
+00:03:07,000 --> 00:03:10,000
+Usually you are doesn't care about all technical stuff.
+
+46
+00:03:11,000 --> 00:03:16,000
+He cares only about end product and about meetings of functional and non-functional requirements.
+
+47
+00:03:17,000 --> 00:03:21,000
+Understanding that your work should be accepted by non-technical person is a key.
+
+48
+00:03:22,000 --> 00:03:27,000
+Usually only see you guys can learn how to talk with product owners, but not always, unfortunately.
+
+49
+00:03:28,000 --> 00:03:35,000
+But understanding your PR and preparing a set of tests that verifies expected behavior will help you
+
+50
+00:03:35,000 --> 00:03:37,000
+to reach the expected quality level.
+
+51
+00:03:37,000 --> 00:03:41,000
+We have just said something about quality and reached an expected quality level.
+
+52
+00:03:42,000 --> 00:03:47,000
+But what is actually a quality that different definitions of a quality?
+
+53
+00:03:47,000 --> 00:03:52,000
+But my own you finish that, in my opinion, describes the quality and software engineer is the most
+
+54
+00:03:52,000 --> 00:03:53,000
+accurate way.
+
+55
+00:03:54,000 --> 00:03:58,000
+It sounds like the following quality is a degree of compliance with the requirements.
+
+56
+00:03:59,000 --> 00:04:02,000
+Good quality means complete compliance with requirements.
+
+57
+00:04:03,000 --> 00:04:05,000
+That quality means opposite.
+
+58
+00:04:05,000 --> 00:04:07,000
+Does it make sense homes?
+
+59
+00:04:07,000 --> 00:04:13,000
+Does it use your understanding what quality is and what we as developers will try to pursue?
+
+60
+00:04:13,000 --> 00:04:17,000
+And we need to right this to meet the expected level of quality?
+
+61
+00:04:17,000 --> 00:04:19,000
+What else do we need?
+
+62
+00:04:19,000 --> 00:04:25,000
+The right tests thus have their own users to understand why we have to write this.
+
+63
+00:04:25,000 --> 00:04:30,000
+Let's review functions that are in charge of increasing team productivity.
+
+64
+00:04:30,000 --> 00:04:36,000
+Team productivity is increased with tests because time spent on regression and manual testing is significantly
+
+65
+00:04:36,000 --> 00:04:37,000
+reduced.
+
+66
+00:04:38,000 --> 00:04:44,000
+I believe that you would love to perform some testing after implementation of a new feature or after
+
+67
+00:04:44,000 --> 00:04:45,000
+small changes, don't you?
+
+68
+00:04:46,000 --> 00:04:49,000
+And as your program grew, it will take more time to test average soon.
+
+69
+00:04:50,000 --> 00:04:57,000
+That's why we developers want to put automated tests on place that will help us to perform checks and
+
+70
+00:04:57,000 --> 00:05:01,000
+now multiplies this benefit by each team member with.
+
+71
+00:05:02,000 --> 00:05:10,000
+Each team member would have a possibility to run them and verify state of the app in no time limit need
+
+72
+00:05:10,000 --> 00:05:10,000
+for the bargain.
+
+73
+00:05:11,000 --> 00:05:17,000
+This is super important in case you've found some defect in your program haven't pursued the course.
+
+74
+00:05:17,000 --> 00:05:23,000
+All your application can help you easily identify where defect is in the best case.
+
+75
+00:05:23,000 --> 00:05:29,000
+Some specific test will be failed, and you will find defect instantly without debugging.
+
+76
+00:05:29,000 --> 00:05:32,000
+In case your tests, you didn't intend to find the defect.
+
+77
+00:05:33,000 --> 00:05:39,000
+That means some test case is missed, and the first thing you have to do in this case is write new tests
+
+78
+00:05:39,000 --> 00:05:42,000
+that will cover an error that was missed.
+
+79
+00:05:42,000 --> 00:05:49,000
+Instead of running and fixing this defect as fast as possible, confidence during the refactoring Rifaximin
+
+80
+00:05:49,000 --> 00:05:56,000
+is a process of restructuring existing code without changing its external behavior and joins a refactoring,
+
+81
+00:05:56,000 --> 00:06:00,000
+you have to be sure that you didn't break any existing functionality.
+
+82
+00:06:01,000 --> 00:06:08,000
+For example, you want to remove redundant code duplication or you want to regroup files in one package
+
+83
+00:06:08,000 --> 00:06:14,000
+or something else, and you have to be sure that you didn't accidentally remove code that is needed.
+
+84
+00:06:14,000 --> 00:06:19,000
+Having ensued of tests, you can constantly run them to make sure you didn't break ineson.
+
+85
+00:06:20,000 --> 00:06:25,000
+Clean cut and good architecture design in this course, we will also learn test driven development and
+
+86
+00:06:25,000 --> 00:06:26,000
+how it works.
+
+87
+00:06:26,000 --> 00:06:33,000
+The huge advantage of this approach is that it fosters being caught and the reliable architecture design.
+
+88
+00:06:34,000 --> 00:06:35,000
+In simple words, right?
+
+89
+00:06:35,000 --> 00:06:41,000
+And this make you think what level of abstraction is needed in your application, how you would like
+
+90
+00:06:41,000 --> 00:06:43,000
+to group classes into packages.
+
+91
+00:06:44,000 --> 00:06:47,000
+What access modifiers should be used for fields and masses and so on.
+
+92
+00:06:48,000 --> 00:06:55,000
+And writing does first helps you to create more usable architecture of your application name and task
+
+93
+00:06:56,000 --> 00:06:57,000
+coverage matchweek.
+
+94
+00:06:57,000 --> 00:07:04,000
+This function seems to be not very useful for you, but sometimes it's important for our customers when
+
+95
+00:07:04,000 --> 00:07:09,000
+you work in outsourcing, company managers from customer site would require from you to provide such
+
+96
+00:07:09,000 --> 00:07:15,000
+metric as desk with coverage that will show how much of the code and application are covered with tests.
+
+97
+00:07:16,000 --> 00:07:22,000
+By the end of this course, you will learn that there is no direct dependency between test code coverage,
+
+98
+00:07:22,000 --> 00:07:24,000
+magic and quality of your application.
+
+99
+00:07:24,000 --> 00:07:30,000
+Also, tests could be written in order to just increase desk with coverage metric, but not actually
+
+100
+00:07:30,000 --> 00:07:31,000
+test your code.
+
+101
+00:07:31,000 --> 00:07:37,000
+I'll show you how this can be, and I'll teach you how to write tests that will actually help you to
+
+102
+00:07:37,000 --> 00:07:40,000
+decrease potential number of defects and the last.
+
+103
+00:07:40,000 --> 00:07:46,000
+But in my opinion, one of the most important duties of tests is to serve as a documentation for your
+
+104
+00:07:46,000 --> 00:07:47,000
+application.
+
+105
+00:07:47,000 --> 00:07:51,000
+Very often, engineers don't write tests for their code.
+
+106
+00:07:51,000 --> 00:07:58,000
+But when generation of people who support this project is changed, nobody can understand why they need
+
+107
+00:07:58,000 --> 00:08:04,000
+this class or why they need this private method and how critical it is or why.
+
+108
+00:08:04,000 --> 00:08:07,000
+Before storing the database, some additional request is sent.
+
+109
+00:08:08,000 --> 00:08:12,000
+Is that business requirements or just redundant method invocation?
+
+110
+00:08:12,000 --> 00:08:19,000
+Well, I imagine that you want on board new team member and instead of telling him or her how to initialize
+
+111
+00:08:19,000 --> 00:08:25,000
+some objects or what should happen to calculate discount for specific user, you just provide him with
+
+112
+00:08:25,000 --> 00:08:26,000
+a link to your test.
+
+113
+00:08:26,000 --> 00:08:33,000
+Well, and as described writing tests, it is similar to having the client that is using your code,
+
+114
+00:08:33,000 --> 00:08:36,000
+and everyone can investigate how to use your code.
+
+115
+00:08:37,000 --> 00:08:40,000
+Oh, now you have full and clear picture why we need that.
+
+116
+00:08:41,000 --> 00:08:46,000
+Let me remind you that in case you have any questions regarding materials that I have shared, you can
+
+117
+00:08:46,000 --> 00:08:49,000
+always ask it in the Q&A section of this lesson.
+
+118
+00:08:49,000 --> 00:08:51,000
+Let's move on now.
+
+119
+00:08:51,000 --> 00:08:54,000
+I want to discuss with you different approaches in testing.
+
+120
+00:08:55,000 --> 00:08:58,000
+This will help you to better understand different levels of testing.
+
+121
+00:08:59,000 --> 00:09:04,000
+There are two main methods of testing Ziya black box testing and one box testing.
+
+122
+00:09:04,000 --> 00:09:10,000
+Black box testing is a method of software testing that examines the functionality of an application
+
+123
+00:09:10,000 --> 00:09:14,000
+without peer into its internal structures or workings.
+
+124
+00:09:14,000 --> 00:09:18,000
+There is no need to have all specifics and details of the code structure.
+
+125
+00:09:19,000 --> 00:09:23,000
+Testers should be aware of expected the behavior of the application.
+
+126
+00:09:23,000 --> 00:09:29,000
+In other words, according to black box approach, testers should know what applications should do,
+
+127
+00:09:29,000 --> 00:09:32,000
+but not necessarily how application does this.
+
+128
+00:09:33,000 --> 00:09:39,000
+On the other hand, white box testing that is also known as a glass box test and transparent box testing
+
+129
+00:09:39,000 --> 00:09:46,000
+is a method of software testing that test in general structures or rockets of an application as opposed
+
+130
+00:09:46,000 --> 00:09:49,000
+to its functionality and black box testing.
+
+131
+00:09:50,000 --> 00:09:55,000
+Depending on which level of testing you perform verification activities, you can apply one or another
+
+132
+00:09:55,000 --> 00:09:56,000
+method.
+
+133
+00:09:56,000 --> 00:09:59,000
+Let's hear on what levels of testing exist.
+
+134
+00:09:59,000 --> 00:10:02,000
+There are multiple testing levels in some literature.
+
+135
+00:10:02,000 --> 00:10:08,000
+You might find four levels, zero unit integration system and acceptance testing.
+
+136
+00:10:09,000 --> 00:10:14,000
+Let's review each layer one by one and understand what is the difference between the levels.
+
+137
+00:10:15,000 --> 00:10:17,000
+Each of the level has its own purpose.
+
+138
+00:10:17,000 --> 00:10:22,000
+For example, goal of unit testing is to test the smallest unit.
+
+139
+00:10:22,000 --> 00:10:26,000
+Usually, it is considered to be the completion unit in Jawa.
+
+140
+00:10:26,000 --> 00:10:27,000
+This is one class.
+
+141
+00:10:28,000 --> 00:10:32,000
+Typically, this type of testing is performed by a programmer, but not a tester.
+
+142
+00:10:32,000 --> 00:10:37,000
+And there's an understanding that on this level, you may want to apply white box approach you as a
+
+143
+00:10:37,000 --> 00:10:44,000
+test, and you have to verify that all massive in this unit works as expected and unifies this without
+
+144
+00:10:44,000 --> 00:10:46,000
+any interaction with other components.
+
+145
+00:10:47,000 --> 00:10:50,000
+Just testing of one single unit is elation.
+
+146
+00:10:50,000 --> 00:10:55,000
+The next level of testing is integration testing on this level of testing.
+
+147
+00:10:55,000 --> 00:11:00,000
+Our goal is to make sure that components work together and may interact between each other.
+
+148
+00:11:01,000 --> 00:11:07,000
+For example, you want to test that after user registration, he or she receives welcome email, and
+
+149
+00:11:07,000 --> 00:11:09,000
+this amount is sent by another class.
+
+150
+00:11:09,000 --> 00:11:15,000
+Your test should include scenarios that will verify that after registration, email is sent.
+
+151
+00:11:16,000 --> 00:11:18,000
+That's why it is called integration testing.
+
+152
+00:11:19,000 --> 00:11:25,000
+The next level of testing is a system testing system, testing is performed on a complete integrated
+
+153
+00:11:25,000 --> 00:11:26,000
+system.
+
+154
+00:11:26,000 --> 00:11:30,000
+It allows checking systems compliance as per the requirements.
+
+155
+00:11:30,000 --> 00:11:37,000
+Usually, system testing includes performance security testing, system testing most often the final
+
+156
+00:11:37,000 --> 00:11:44,000
+test to verify that the system is a specification, it verifies both functional and non-functional requirements.
+
+157
+00:11:44,000 --> 00:11:50,000
+And finally, acceptance testing acceptance testing is a test conducted to find if all requirements
+
+158
+00:11:50,000 --> 00:11:50,000
+are met.
+
+159
+00:11:51,000 --> 00:11:54,000
+That's final level of testing before acceptance.
+
+160
+00:11:54,000 --> 00:11:59,000
+Software product unions acceptance testing, we have to give an answer whether product is ready for
+
+161
+00:11:59,000 --> 00:12:00,000
+release.
+
+162
+00:12:00,000 --> 00:12:02,000
+That's it regarding testing levels.
+
+163
+00:12:02,000 --> 00:12:05,000
+I hope this gives you an understanding of the whole test process.
+
+164
+00:12:06,000 --> 00:12:10,000
+Usually, software developers are in charge or writing unit integration.
+
+165
+00:12:10,000 --> 00:12:15,000
+That's sometimes functional tests can be written by key automation engineers.
+
+166
+00:12:15,000 --> 00:12:20,000
+And then the course we're going to learn the tools and techniques that will help you to write tests.
+
+167
+00:12:21,000 --> 00:12:24,000
+Also, I'd like to cover today was your test and concept.
+
+168
+00:12:25,000 --> 00:12:26,000
+What is this?
+
+169
+00:12:26,000 --> 00:12:33,000
+Impairment test impairment is a framework that can help both developers and kids to create high quality
+
+170
+00:12:33,000 --> 00:12:34,000
+software.
+
+171
+00:12:34,000 --> 00:12:41,000
+It reduces the time required for developers to identify if a change they introduce Brexit code.
+
+172
+00:12:41,000 --> 00:12:45,000
+It can also be helpful in building a more reliable tests.
+
+173
+00:12:46,000 --> 00:12:52,000
+Essentially, the testing permit also referred to as test automation pyramid.
+
+174
+00:12:52,000 --> 00:12:59,000
+These are the types of tests that should be included in an automated tests used on different test levels.
+
+175
+00:12:59,000 --> 00:13:03,000
+It also outlines a sequence and frequency of these tests.
+
+176
+00:13:04,000 --> 00:13:11,000
+The whole point is to offer immediate feedback to ensure that the code changes do not disrupt existing
+
+177
+00:13:11,000 --> 00:13:19,000
+features so we can treat this impairment as way of thinking how we can balance different types of tests
+
+178
+00:13:19,000 --> 00:13:26,000
+on different levels and important conclusions that we can make out of the testing pyramid is that we
+
+179
+00:13:26,000 --> 00:13:29,000
+have to have solid layer of unit tests.
+
+180
+00:13:29,000 --> 00:13:35,000
+And on the basis of unit tests, you build your pyramid on ozone levels of testing.
+
+181
+00:13:35,000 --> 00:13:42,000
+This pyramid provides all team was right priorities in case the management team puts significant focus
+
+182
+00:13:42,000 --> 00:13:49,000
+on the tests without paying attention, the unit does the higher chances of missing some critical defect.
+
+183
+00:13:49,000 --> 00:13:54,000
+You must say that in case you will have only internal tests, that means you are completely covered
+
+184
+00:13:54,000 --> 00:13:57,000
+from defects that important customer and product owner.
+
+185
+00:13:57,000 --> 00:13:59,000
+But what about functions of testing?
+
+186
+00:14:00,000 --> 00:14:02,000
+Yet this serves as a documentation.
+
+187
+00:14:02,000 --> 00:14:05,000
+Two unit tests are forced to execute.
+
+188
+00:14:06,000 --> 00:14:13,000
+Usually, internal tests requires all components of application up and running, and this could be not
+
+189
+00:14:13,000 --> 00:14:13,000
+the case.
+
+190
+00:14:13,000 --> 00:14:19,000
+One hundred percent of your work and time because other parts of the system are also in progress of
+
+191
+00:14:19,000 --> 00:14:26,000
+development and the parallel development e.g. develop a test its own human that was written by an after
+
+192
+00:14:26,000 --> 00:14:32,000
+that goes integration tests and after that go system testing and acceptance testing.
+
+193
+00:14:32,000 --> 00:14:38,000
+There is one interesting metric that the so-called defect cost increase the cost of fixing the book
+
+194
+00:14:38,000 --> 00:14:44,000
+or defect is lower if you catch it in the design phase, but higher in later phases of the software
+
+195
+00:14:44,000 --> 00:14:46,000
+development lifecycle.
+
+196
+00:14:46,000 --> 00:14:52,000
+The cost of detecting and fixing defects in software increases exponentially, with time in the software
+
+197
+00:14:52,000 --> 00:15:00,000
+development workflow fixing box and the field is incredibly costly and risky, often by an order of
+
+198
+00:15:00,000 --> 00:15:01,000
+magnitude or two.
+
+199
+00:15:01,000 --> 00:15:07,000
+The cost is not just in the form of time and resources wasted in the present, but also in the form
+
+200
+00:15:07,000 --> 00:15:10,000
+of lost opportunities in the future.
+
+201
+00:15:10,000 --> 00:15:18,000
+For example, imagine that you have a bank that some mobile Mac and one user noticed that when he sends
+
+202
+00:15:18,000 --> 00:15:24,000
+one hundred dollars, he got extra charged for money transfer for ten more dollars.
+
+203
+00:15:24,000 --> 00:15:30,000
+And there were no end in the case about extra charge for money transfer of specific money amount.
+
+204
+00:15:30,000 --> 00:15:31,000
+Do not the banks.
+
+205
+00:15:32,000 --> 00:15:38,000
+And this is a bug because users should have seen this notification not pop up the items.
+
+206
+00:15:39,000 --> 00:15:44,000
+Your team submitted a defect, but how much will it cost to you at the end of the day?
+
+207
+00:15:45,000 --> 00:15:51,000
+Well, you can come up with some other example like user downloaded app to send money, but he can't
+
+208
+00:15:51,000 --> 00:15:53,000
+because app is not working.
+
+209
+00:15:54,000 --> 00:15:56,000
+User just removes app, and that's it.
+
+210
+00:15:57,000 --> 00:16:02,000
+You spend so much money on advertisement domains as client download your app.
+
+211
+00:16:02,000 --> 00:16:08,000
+And now he just left, and he will never install the app one more time again in the future.
+
+212
+00:16:08,000 --> 00:16:15,000
+Moreover, this guide may leave bad feedback on different portals and new clients will doubt in your
+
+213
+00:16:15,000 --> 00:16:16,000
+app.
+
+214
+00:16:16,000 --> 00:16:20,000
+This also, of course, is that you have lost the understands this.
+
+215
+00:16:21,000 --> 00:16:25,000
+Remember that the price of fixing the effect is increasing from an environment environment.
+
+216
+00:16:26,000 --> 00:16:32,000
+The cheapest price you can pay is to figure out the effect on local computer in case the effect was
+
+217
+00:16:32,000 --> 00:16:34,000
+discovered on a service.
+
+218
+00:16:34,000 --> 00:16:40,000
+It requires additional a force to use to gauge in the effort to fix it, to deploy it on key environment,
+
+219
+00:16:41,000 --> 00:16:45,000
+to perform some testing, to make sure that other features are not broken.
+
+220
+00:16:45,000 --> 00:16:51,000
+If the effect was discovered during user acceptance testing, that's completely another procedure.
+
+221
+00:16:51,000 --> 00:16:57,000
+We'll talk another lessons about continuous integration and continuous delivery and deployment, and
+
+222
+00:16:57,000 --> 00:17:02,000
+we'll elaborate more on different environments that we use during the development.
+
+223
+00:17:02,000 --> 00:17:09,000
+But the things that you should remember right now is that you have to be able to identify a potential
+
+224
+00:17:09,000 --> 00:17:16,000
+defect as early as possible and and Pyramid set the right priorities for us while writing our series
+
+225
+00:17:16,000 --> 00:17:17,000
+of tests.
+
+226
+00:17:18,000 --> 00:17:24,000
+Before moving further and learning other classifications related to Destin, I want to understand a
+
+227
+00:17:24,000 --> 00:17:26,000
+few more basic concepts.
+
+228
+00:17:26,000 --> 00:17:31,000
+I want to discuss with you what functional and non-functional requirements are.
+
+229
+00:17:31,000 --> 00:17:33,000
+Let's start from running functional requirements.
+
+230
+00:17:34,000 --> 00:17:37,000
+Functional requirements defines a basic system behavior.
+
+231
+00:17:38,000 --> 00:17:46,000
+Essentially, Zara, what system does or must not do and can be sought often in terms of how the system
+
+232
+00:17:46,000 --> 00:17:47,000
+responds to inputs.
+
+233
+00:17:48,000 --> 00:17:55,000
+Functional requirements user to define exact behaviors and includes calculations, data input and business
+
+234
+00:17:55,000 --> 00:17:56,000
+processes.
+
+235
+00:17:56,000 --> 00:18:03,000
+In other more simple words, we can treat functional requirements as features that allows the system
+
+236
+00:18:03,000 --> 00:18:05,000
+to function as it was intended.
+
+237
+00:18:06,000 --> 00:18:10,000
+Simply said it was the functional requirements are not met.
+
+238
+00:18:10,000 --> 00:18:12,000
+This system will not work.
+
+239
+00:18:12,000 --> 00:18:19,000
+Functional requirements are product features and focus on user requirements, while functional requirements
+
+240
+00:18:19,000 --> 00:18:22,000
+define what the system does or must not do.
+
+241
+00:18:23,000 --> 00:18:27,000
+Non-functional requirements specify how this system should do it.
+
+242
+00:18:27,000 --> 00:18:32,000
+Non-functional requirements do not affect the basic functionality of the system.
+
+243
+00:18:33,000 --> 00:18:38,000
+Hence the name is non-functional requirements even if the non-functional requirements are not met.
+
+244
+00:18:39,000 --> 00:18:42,000
+The system will still perform its basic purpose.
+
+245
+00:18:42,000 --> 00:18:46,000
+If a system will still perform results, meetings is non-functional requirements.
+
+246
+00:18:47,000 --> 00:18:48,000
+Why are they important?
+
+247
+00:18:49,000 --> 00:18:51,000
+The answer is usability.
+
+248
+00:18:51,000 --> 00:18:57,000
+Non-functional requirements define system behaviour, features and general characteristics that affect
+
+249
+00:18:57,000 --> 00:18:58,000
+the user experience.
+
+250
+00:18:59,000 --> 00:19:06,000
+How well known functional requirements are defined and executed determines how easily this system used
+
+251
+00:19:06,000 --> 00:19:09,000
+to use and is used to judge system performance.
+
+252
+00:19:10,000 --> 00:19:16,000
+Non-functional requirements are product properties and focus on user expectations.
+
+253
+00:19:17,000 --> 00:19:18,000
+Great.
+
+254
+00:19:18,000 --> 00:19:22,000
+You know what, functional and non-functional requirements are.
+
+255
+00:19:22,000 --> 00:19:26,000
+Now let's learn what functional and non-functional destiny is.
+
+256
+00:19:26,000 --> 00:19:33,000
+One more important things that we need to understand about testing software testing is broadly categorised
+
+257
+00:19:33,000 --> 00:19:35,000
+into functional and non-functional testing.
+
+258
+00:19:36,000 --> 00:19:38,000
+You already know different testing levels.
+
+259
+00:19:38,000 --> 00:19:43,000
+Also, you know what functional and non-functional requirements are, and I believe it will be easier
+
+260
+00:19:43,000 --> 00:19:48,000
+for you to understand such categories as functional and non-functional testing.
+
+261
+00:19:49,000 --> 00:19:55,000
+Let's discuss in detail about these testing types functional testing because the type of test and which
+
+262
+00:19:55,000 --> 00:20:01,000
+verifies that each function of the software application operates in conformance with the requirements
+
+263
+00:20:01,000 --> 00:20:02,000
+specification.
+
+264
+00:20:03,000 --> 00:20:10,000
+This test mainly involves black box testing, and it is not concerned about the source code of the application.
+
+265
+00:20:11,000 --> 00:20:14,000
+Usually, this is verification of entry and snares.
+
+266
+00:20:15,000 --> 00:20:22,000
+So you test behavior of the system according to the requirements, and to end, every functionality
+
+267
+00:20:22,000 --> 00:20:25,000
+of this system is tested by providing appropriate input.
+
+268
+00:20:25,000 --> 00:20:30,000
+Verifying the output and comparing the actual result was expected to results.
+
+269
+00:20:31,000 --> 00:20:39,000
+This test involves chicken of user interface APIs, database client server applications and functionality
+
+270
+00:20:39,000 --> 00:20:41,000
+of the application on the test.
+
+271
+00:20:42,000 --> 00:20:43,000
+The testing can be done.
+
+272
+00:20:43,000 --> 00:20:45,000
+Is it manually or using automation?
+
+273
+00:20:46,000 --> 00:20:51,000
+Non-functional testing checks all the aspects not covered in functional tests.
+
+274
+00:20:52,000 --> 00:20:56,000
+In other words, not a functional test and covers verification of non-functional requirements.
+
+275
+00:20:57,000 --> 00:21:02,000
+There are some aspects which are complex, such as performance of an application, etc. and this test
+
+276
+00:21:02,000 --> 00:21:05,000
+and check the quality of the software to be tested.
+
+277
+00:21:06,000 --> 00:21:13,000
+Quality majorly depends on time, accuracy, stability, correctness and durability of a product and
+
+278
+00:21:13,000 --> 00:21:17,000
+the various adverse circumstances in software terms.
+
+279
+00:21:17,000 --> 00:21:24,000
+When an application works as per the user expectation, smoothly and efficiently under any condition,
+
+280
+00:21:24,000 --> 00:21:30,000
+then it is stated as a reliable application based on these aspects of quality.
+
+281
+00:21:31,000 --> 00:21:34,000
+It is very critical to test under these parameters.
+
+282
+00:21:34,000 --> 00:21:38,000
+This type of testing is called non-functional testing.
+
+283
+00:21:38,000 --> 00:21:41,000
+It is not feasible to test this type manually.
+
+284
+00:21:41,000 --> 00:21:48,000
+Hence, some special automated tools are used to test it to help you understand the difference between
+
+285
+00:21:48,000 --> 00:21:51,000
+functional and non-functional testing matter.
+
+286
+00:21:51,000 --> 00:21:54,000
+Let me demonstrate its unreal example.
+
+287
+00:21:54,000 --> 00:22:02,000
+Imagine that we are testing system, and here are questions that we will ask ourselves Do you functional
+
+288
+00:22:02,000 --> 00:22:03,000
+and non-functional testing?
+
+289
+00:22:04,000 --> 00:22:11,000
+Thus, this will impact on the way how we approach our testing functional testing questions.
+
+290
+00:22:11,000 --> 00:22:16,000
+Are these a confirmation email sent after the user registers on the website?
+
+291
+00:22:17,000 --> 00:22:19,000
+Does a feedback notification appear?
+
+292
+00:22:19,000 --> 00:22:26,000
+Is a user uploads a larger files and the system asks when the user clicks on the icons that is supposed
+
+293
+00:22:26,000 --> 00:22:27,000
+to be clickable.
+
+294
+00:22:27,000 --> 00:22:29,000
+Does a new page load?
+
+295
+00:22:30,000 --> 00:22:33,000
+As you can see, all questions are behavior oriented.
+
+296
+00:22:34,000 --> 00:22:40,000
+Non-functional testing questions are how much time does it take for the user to receive a registration
+
+297
+00:22:40,000 --> 00:22:42,000
+confirmation email?
+
+298
+00:22:42,000 --> 00:22:47,000
+Does the feedback notification comply with the principles of user friendly push notifications?
+
+299
+00:22:47,000 --> 00:22:50,000
+Design the transparency for the user?
+
+300
+00:22:50,000 --> 00:22:52,000
+Where to click the lower than you page.
+
+301
+00:22:53,000 --> 00:23:00,000
+I believe you noticed that non-functional testing questions are more about how program works rather
+
+302
+00:23:00,000 --> 00:23:01,000
+than what it does.
+
+303
+00:23:02,000 --> 00:23:03,000
+It feels the difference.
+
+304
+00:23:03,000 --> 00:23:06,000
+I believe you do now.
+
+305
+00:23:06,000 --> 00:23:11,000
+When you understand the difference between a functional and non-functional testing, let's group different
+
+306
+00:23:11,000 --> 00:23:14,000
+testing strategies into two categories.
+
+307
+00:23:14,000 --> 00:23:22,000
+Such testing strategies can be added to functional testing group smoke testing, sanity testing, unit
+
+308
+00:23:22,000 --> 00:23:31,000
+testing, integration testing, boundary value testing, API testing, user acceptance testing, regression
+
+309
+00:23:31,000 --> 00:23:38,000
+testing, interoperability, testing and such testing strategies can be considered as non-functional
+
+310
+00:23:38,000 --> 00:23:46,000
+testing activities and reliability testing, performance, testing, compatibility, testing, localization,
+
+311
+00:23:46,000 --> 00:23:54,000
+testing, William testing, scalability, testing, usability testing, reliability testing, security
+
+312
+00:23:54,000 --> 00:24:02,000
+testing, penetration testing, accessibility testing, load testing, endurance testing, compliance
+
+313
+00:24:02,000 --> 00:24:09,000
+testing, stress testing, Menton ability testing, portability testing, disaster recovery testing
+
+314
+00:24:09,000 --> 00:24:12,000
+is everything clear to you anyway.
+
+315
+00:24:12,000 --> 00:24:16,000
+Even in case you still have any questions, do not hesitate to ask me in.
+
+316
+00:24:17,000 --> 00:24:20,000
+Comments on this video, and I will be happy to answer.
+
+317
+00:24:22,000 --> 00:24:22,000
+That's it.
+
+318
+00:24:22,000 --> 00:24:29,000
+Now let's recap what we have learned today to live and learn what testing is and why do we need it now,
+
+319
+00:24:29,000 --> 00:24:36,000
+you know what goes of testing are worthy of testing approaches and testing levels after today's lesson.
+
+320
+00:24:36,000 --> 00:24:40,000
+You know what level of tests are usually written by developers?
+
+321
+00:24:40,000 --> 00:24:43,000
+Besides that, you learned what quality is.
+
+322
+00:24:43,000 --> 00:24:46,000
+We learned what tests impairment is.
+
+323
+00:24:46,000 --> 00:24:50,000
+Also, we discussed the difference between functional and non-functional requirements.
+
+324
+00:24:51,000 --> 00:24:55,000
+And at the end of the lesson, we have learnt what functional and non-functional testing is.
+
+325
+00:24:56,000 --> 00:24:58,000
+That's all for this lesson.
+
+326
+00:24:58,000 --> 00:24:59,000
+Thanks a lot for your attention.
+
+327
+00:25:00,000 --> 00:25:01,000
+See you in the next lesson.
+

34 - Unit Testing & JUnit 5/001 Unit Testing & JUnit Overview_en.srt

@@ -0,0 +1,1372 @@
+1
+00:00:06,000 --> 00:00:10,000
+Heard yesterday in this lesson, we learned basics of human testing.
+
+2
+00:00:10,000 --> 00:00:12,000
+We are going to learn today what unit testing is.
+
+3
+00:00:12,000 --> 00:00:16,000
+You understand basic principles of unit testing.
+
+4
+00:00:16,000 --> 00:00:20,000
+And after that, we are going to review libraries for unit testing in Java.
+
+5
+00:00:20,000 --> 00:00:26,000
+We'll focus our attention on the one of the most popular libraries for unit testing and Java G unit.
+
+6
+00:00:26,000 --> 00:00:32,000
+I will explain the basic structure of this library and we'll teach you how that extra libraries to your
+
+7
+00:00:32,000 --> 00:00:34,000
+project in Eclipse by the end of the.
+
+8
+00:00:35,000 --> 00:00:38,000
+And you'll write your first unit test during the lesson.
+
+9
+00:00:38,000 --> 00:00:42,000
+I will share with you tips and best practices of writing unit tests.
+
+10
+00:00:42,000 --> 00:00:46,000
+So be prepared for interesting lecture and learn a lot of new things.
+
+11
+00:00:46,000 --> 00:00:49,000
+Let's start at the beginning of the lesson.
+
+12
+00:00:49,000 --> 00:00:55,000
+We'll talk about Syria of testing to make sure that by the moment we start right, our first test,
+
+13
+00:00:55,000 --> 00:00:59,000
+you understand what we are going to do in the middle of our lesson.
+
+14
+00:00:59,000 --> 00:01:03,000
+We'll learn how to use Genin by refining and testing in Java.
+
+15
+00:01:03,000 --> 00:01:09,000
+And at the end of the lesson, we'll dive deeper into the specifics of new tests from the previous class.
+
+16
+00:01:09,000 --> 00:01:14,000
+And you remember that new testing help us to test each specific unit of completion.
+
+17
+00:01:15,000 --> 00:01:17,000
+That is our classes with unit tests.
+
+18
+00:01:17,000 --> 00:01:23,000
+We have the ability and to to verify that each unit behaves in the way it expects to behave.
+
+19
+00:01:24,000 --> 00:01:26,000
+Does that mean that your program works 100 percent?
+
+20
+00:01:26,000 --> 00:01:26,000
+Correct?
+
+21
+00:01:27,000 --> 00:01:28,000
+Not necessarily.
+
+22
+00:01:28,000 --> 00:01:29,000
+Why?
+
+23
+00:01:29,000 --> 00:01:35,000
+Because each specific unit can work as expected, but together a few classes don't work as expected
+
+24
+00:01:36,000 --> 00:01:42,000
+is a some invalid input or one module works with a specific range of data that is invalid relative to
+
+25
+00:01:42,000 --> 00:01:43,000
+another class.
+
+26
+00:01:43,000 --> 00:01:45,000
+Or we missed some specific test case.
+
+27
+00:01:45,000 --> 00:01:52,000
+And the only reason our unit test passed successfully is that because it's simply absent a test is a
+
+28
+00:01:52,000 --> 00:01:59,000
+piece of good reason by a developer that executes a specific functionality in the code to be tested
+
+29
+00:01:59,000 --> 00:02:02,000
+and asserts a certain behavior or state.
+
+30
+00:02:03,000 --> 00:02:07,000
+Each test contains specific research that will verify specific state.
+
+31
+00:02:08,000 --> 00:02:14,000
+The percentage of code which is tested by unit tests is typically called test coverage will learn tools
+
+32
+00:02:14,000 --> 00:02:17,000
+that help us to verify test got coverage in adolescence.
+
+33
+00:02:18,000 --> 00:02:24,000
+Any tests are not suitable for testing complex user interfaces or component interactions.
+
+34
+00:02:24,000 --> 00:02:27,000
+For this, you should develop integration tests.
+
+35
+00:02:27,000 --> 00:02:31,000
+But unit tests can detect issues as early as possible.
+
+36
+00:02:31,000 --> 00:02:33,000
+They form the base of our test permit.
+
+37
+00:02:34,000 --> 00:02:41,000
+Now let's review basic principles of unit testing, the simple rules that we need to follow to make
+
+38
+00:02:41,000 --> 00:02:43,000
+sure our unit tests efficient.
+
+39
+00:02:43,000 --> 00:02:49,000
+Zaya the first through one assertion per test or single concept by test.
+
+40
+00:02:49,000 --> 00:02:55,000
+That means in case we test discount calculation, we don't have to create one test.
+
+41
+00:02:55,000 --> 00:03:01,000
+The test calculation of this controversial card was one product with total price of hundred bucks and
+
+42
+00:03:01,000 --> 00:03:07,000
+in the same tests verify amount of discount in case of the card with total price one thousand bucks.
+
+43
+00:03:08,000 --> 00:03:13,000
+In other words, one test shouldn't verify different test cases in scope of the same test.
+
+44
+00:03:14,000 --> 00:03:20,000
+There are some exceptions when this single concept by test in this case with this money transferring
+
+45
+00:03:20,000 --> 00:03:25,000
+from one account to another and we have test case that should verify my transaction.
+
+46
+00:03:25,000 --> 00:03:31,000
+In this case, we have to check that on one account amount of money was decreased because we sent them
+
+47
+00:03:31,000 --> 00:03:36,000
+to another account and on that last account, amount of money should be increased.
+
+48
+00:03:37,000 --> 00:03:39,000
+That's called single concept by test.
+
+49
+00:03:40,000 --> 00:03:44,000
+And we have to verifications in scope of the same test.
+
+50
+00:03:44,000 --> 00:03:51,000
+We need to separate test based scenarios to be able to catch error faster and to understand what specific
+
+51
+00:03:51,000 --> 00:03:52,000
+scenario didn't pass.
+
+52
+00:03:53,000 --> 00:03:59,000
+The second rule of human testing is that we have to test one single object at a time in case with some
+
+53
+00:03:59,000 --> 00:04:05,000
+service, for example, or the management service we shouldn't test or the store and service at the
+
+54
+00:04:05,000 --> 00:04:06,000
+same time.
+
+55
+00:04:06,000 --> 00:04:13,000
+Unit testing is about testing one single unit in isolation and without testing simultaneously different
+
+56
+00:04:13,000 --> 00:04:14,000
+units.
+
+57
+00:04:14,000 --> 00:04:20,000
+We have to test each unit separately and independently to make sure that the root cause of the error
+
+58
+00:04:20,000 --> 00:04:22,000
+is in this specific unit.
+
+59
+00:04:22,000 --> 00:04:24,000
+And that's the test case.
+
+60
+00:04:24,000 --> 00:04:26,000
+Failure is not caused by another class.
+
+61
+00:04:27,000 --> 00:04:29,000
+That's why you run the unit testing.
+
+62
+00:04:29,000 --> 00:04:34,000
+You want to isolate units from each other and test only one object at a time.
+
+63
+00:04:35,000 --> 00:04:40,000
+And the surge rule, one of the most important ones, choose meaningful test method names.
+
+64
+00:04:41,000 --> 00:04:42,000
+Why it is so important?
+
+65
+00:04:42,000 --> 00:04:47,000
+Because, as you remember, one of the functions of testing is to serve as a documentation.
+
+66
+00:04:48,000 --> 00:04:52,000
+That's why it is critically important to give meaningful names to each test.
+
+67
+00:04:53,000 --> 00:04:54,000
+Test should be readable.
+
+68
+00:04:54,000 --> 00:04:59,000
+Well, all codes should be readable, but this is critical, especially for tests.
+
+69
+00:05:00,000 --> 00:05:06,000
+That's why it is okay to have extremely long, massive names in unit tests that clearly describes a
+
+70
+00:05:06,000 --> 00:05:06,000
+test case.
+
+71
+00:05:07,000 --> 00:05:10,000
+It is also important to give clear names to all constants.
+
+72
+00:05:11,000 --> 00:05:16,000
+There is also Antipodeans that is called magic numbers, magic numbers and numbers.
+
+73
+00:05:16,000 --> 00:05:18,000
+It is not clear where do they come from?
+
+74
+00:05:18,000 --> 00:05:24,000
+Where does this maximum relative value or minimum value or this is just a random value.
+
+75
+00:05:24,000 --> 00:05:25,000
+What does it mean?
+
+76
+00:05:26,000 --> 00:05:32,000
+That's why each number should be assigned to a specific constant with the relevant name, especially
+
+77
+00:05:32,000 --> 00:05:33,000
+in tests.
+
+78
+00:05:33,000 --> 00:05:37,000
+Now, you know, Maine rules that can be applied to each year union test.
+
+79
+00:05:38,000 --> 00:05:39,000
+Let's proceed.
+
+80
+00:05:39,000 --> 00:05:43,000
+Now, I'd like to discuss with you a few more testing principles.
+
+81
+00:05:43,000 --> 00:05:50,000
+There are a set of principles called First Leavis acronym, composed from the first letters of the principal's
+
+82
+00:05:50,000 --> 00:05:50,000
+name.
+
+83
+00:05:50,000 --> 00:05:56,000
+And the minute you will believe me that this is not just offensive word, but indeed a set of useful
+
+84
+00:05:56,000 --> 00:05:56,000
+principles.
+
+85
+00:05:57,000 --> 00:06:00,000
+Let's start from the first one F stands for first.
+
+86
+00:06:01,000 --> 00:06:06,000
+A developer should not hesitate to run the unit tests because they are very slow and you need to grab
+
+87
+00:06:06,000 --> 00:06:08,000
+a cup of coffee to wake you.
+
+88
+00:06:08,000 --> 00:06:10,000
+All verifications will be done.
+
+89
+00:06:10,000 --> 00:06:18,000
+Nobody should be scared of running a union test because of the time they take the top of each preconditioning
+
+90
+00:06:18,000 --> 00:06:21,000
+test and gear down should execute really fast.
+
+91
+00:06:22,000 --> 00:06:27,000
+I mean, it is a matter of milliseconds because there are thousands of units in one project.
+
+92
+00:06:28,000 --> 00:06:30,000
+The next letter is I.
+
+93
+00:06:30,000 --> 00:06:33,000
+I stands for independent or isolated.
+
+94
+00:06:33,000 --> 00:06:37,000
+Each test should be isolated from external environment.
+
+95
+00:06:37,000 --> 00:06:43,000
+Each test should be independent of anything else, like another test environment for a specific user
+
+96
+00:06:43,000 --> 00:06:51,000
+input and so on, in case you expect from user input simulated for each specific test, because it may
+
+97
+00:06:51,000 --> 00:06:57,000
+be different shows that your code can work with the range of values and the result will be different.
+
+98
+00:06:57,000 --> 00:07:03,000
+We'll talk a little bit later how to make sure that we wrote enough tests to avoid the case.
+
+99
+00:07:03,000 --> 00:07:06,000
+When you write hundreds of tests, the test actually is the same thing.
+
+100
+00:07:07,000 --> 00:07:12,000
+There was a case in my life when a colleague of mine from United Kingdom wrote a test that successfully
+
+101
+00:07:13,000 --> 00:07:18,000
+only in his time zone, in time zone of team members from other countries, it failed.
+
+102
+00:07:19,000 --> 00:07:25,000
+Remember, if you use time in assertion of your test, make sure it doesn't depend from the time zone.
+
+103
+00:07:26,000 --> 00:07:31,000
+JDK contains a lot of classes and tools to work with time and to imitate specific time zone.
+
+104
+00:07:31,000 --> 00:07:35,000
+So make sure your tests are independent.
+
+105
+00:07:35,000 --> 00:07:36,000
+Let's go forward.
+
+106
+00:07:37,000 --> 00:07:39,000
+Are stands for repeatable?
+
+107
+00:07:39,000 --> 00:07:45,000
+That means that multiple execution of tests should provide us with the same result in case nothing was
+
+108
+00:07:45,000 --> 00:07:46,000
+changed in the source code.
+
+109
+00:07:46,000 --> 00:07:53,000
+For example, you wrote test that checks registration process after user sign up information about users
+
+110
+00:07:53,000 --> 00:07:59,000
+should be inserted in database and after you paste that user info in the database and run test one more
+
+111
+00:07:59,000 --> 00:08:05,000
+time, it failed because user research A or email already exist in database.
+
+112
+00:08:05,000 --> 00:08:06,000
+Can you understand this example?
+
+113
+00:08:07,000 --> 00:08:14,000
+That means even if you perform any data manipulations with database in our example, you have to clean
+
+114
+00:08:14,000 --> 00:08:16,000
+up everything after each test is finished.
+
+115
+00:08:16,000 --> 00:08:21,000
+And I believe that you understood that database is just one of examples.
+
+116
+00:08:21,000 --> 00:08:23,000
+The main idea is the following.
+
+117
+00:08:24,000 --> 00:08:29,000
+In case your test in some way changed the environment, you have to clean up everything after test is
+
+118
+00:08:29,000 --> 00:08:30,000
+finished.
+
+119
+00:08:30,000 --> 00:08:33,000
+Result of each test should be deterministic.
+
+120
+00:08:33,000 --> 00:08:36,000
+Developers should take control of everything.
+
+121
+00:08:36,000 --> 00:08:38,000
+What is going on in the test?
+
+122
+00:08:38,000 --> 00:08:40,000
+To reproduce different life cases?
+
+123
+00:08:40,000 --> 00:08:44,000
+Each test should set up its own data and should.
+
+124
+00:08:44,000 --> 00:08:50,000
+Not depend on any external factors to run its test, the next letter is S.
+
+125
+00:08:50,000 --> 00:08:56,000
+S stands for self validating no manual inspection where the test is passed on what is required.
+
+126
+00:08:57,000 --> 00:09:02,000
+The same manual configuration is required to execute test, to run tests.
+
+127
+00:09:02,000 --> 00:09:04,000
+Make sure that database is clear.
+
+128
+00:09:04,000 --> 00:09:06,000
+What run this test.
+
+129
+00:09:06,000 --> 00:09:08,000
+Make sure that resourceful clean.
+
+130
+00:09:08,000 --> 00:09:11,000
+You shouldn't declare any conditions like this.
+
+131
+00:09:11,000 --> 00:09:15,000
+And the last letter is key in different sources of literature.
+
+132
+00:09:15,000 --> 00:09:17,000
+It is explained in a different way.
+
+133
+00:09:18,000 --> 00:09:24,000
+Somebody tells the G stands for Sulloway and somebody tells the T stands for timely.
+
+134
+00:09:24,000 --> 00:09:27,000
+I would say that both of these statements are important.
+
+135
+00:09:28,000 --> 00:09:32,000
+SORU means the next should cover all the happy pass.
+
+136
+00:09:32,000 --> 00:09:37,000
+Try covering all the edge cases where the author would feel the function would fail.
+
+137
+00:09:38,000 --> 00:09:40,000
+Test for legal arguments and variables.
+
+138
+00:09:40,000 --> 00:09:42,000
+Test for security and other issues.
+
+139
+00:09:43,000 --> 00:09:44,000
+Test for launch failures.
+
+140
+00:09:44,000 --> 00:09:51,000
+What would a launch in that program should try to cover every use case scenario and not just aim for
+
+141
+00:09:51,000 --> 00:09:58,000
+one hundred percent test got coverage and timely means that test should be written right on time.
+
+142
+00:09:59,000 --> 00:10:04,000
+That means together with the code creation and even better before code creation.
+
+143
+00:10:05,000 --> 00:10:08,000
+I'm talking about so-called test development.
+
+144
+00:10:08,000 --> 00:10:10,000
+We'll talk about this in a separate lesson.
+
+145
+00:10:11,000 --> 00:10:13,000
+So don't be bothered about it right now.
+
+146
+00:10:13,000 --> 00:10:21,000
+Just remember that the best practice is to write test even before you created code on this slide.
+
+147
+00:10:21,000 --> 00:10:24,000
+I would like to talk with you about each test case structure.
+
+148
+00:10:24,000 --> 00:10:27,000
+I am talking about so-called built separate check partan.
+
+149
+00:10:28,000 --> 00:10:31,000
+Somebody also called this three a pattern.
+
+150
+00:10:31,000 --> 00:10:36,000
+Also, it is similar to even when Zen approach described in vague technique.
+
+151
+00:10:36,000 --> 00:10:41,000
+What all this say about these patterns are about basic test structure.
+
+152
+00:10:42,000 --> 00:10:44,000
+Let's review first built separate check pattern.
+
+153
+00:10:44,000 --> 00:10:46,000
+We build up test data first.
+
+154
+00:10:47,000 --> 00:10:50,000
+That is so-called precondition for each test.
+
+155
+00:10:50,000 --> 00:10:56,000
+We have to reproduce specific state of the system as a specific moment of time to verify how the system
+
+156
+00:10:56,000 --> 00:10:56,000
+behaves.
+
+157
+00:10:57,000 --> 00:11:03,000
+For example, we set amount of products in our virtual car and we associate this card with a specific
+
+158
+00:11:03,000 --> 00:11:07,000
+user and after that we operate on that data.
+
+159
+00:11:07,000 --> 00:11:09,000
+We perform some action.
+
+160
+00:11:09,000 --> 00:11:14,000
+In this part, we call some specific method to change the state of our test object.
+
+161
+00:11:15,000 --> 00:11:17,000
+And in the last part it is called check.
+
+162
+00:11:18,000 --> 00:11:19,000
+We perform validation.
+
+163
+00:11:20,000 --> 00:11:23,000
+Specific assertion should be performed in this part of the test.
+
+164
+00:11:24,000 --> 00:11:31,000
+We verify that actual state of our test object is equal to our expected state to make sure the test
+
+165
+00:11:31,000 --> 00:11:32,000
+passed successfully.
+
+166
+00:11:33,000 --> 00:11:35,000
+The next pardon is called 3A.
+
+167
+00:11:36,000 --> 00:11:44,000
+This is about the same three a stands for a act and asserts in the range part, we prepared data in
+
+168
+00:11:44,000 --> 00:11:47,000
+ACT part, modify that data by calling some assets.
+
+169
+00:11:47,000 --> 00:11:50,000
+And in a certain part, we perform assertion.
+
+170
+00:11:50,000 --> 00:11:53,000
+And bit later in this course, we are going to learn.
+
+171
+00:11:54,000 --> 00:11:59,000
+But already now you can understand that to describe expected behavior, we can use a given Van Zandt
+
+172
+00:11:59,000 --> 00:12:00,000
+pardon.
+
+173
+00:12:00,000 --> 00:12:06,000
+Even part describes what we have at the beginning what a regional state of our system is.
+
+174
+00:12:07,000 --> 00:12:14,000
+One part describes a specific action when something this happened, then it turns out that we have such
+
+175
+00:12:14,000 --> 00:12:15,000
+results.
+
+176
+00:12:15,000 --> 00:12:20,000
+So in Zenker, we have assertion to verify our behavior.
+
+177
+00:12:21,000 --> 00:12:24,000
+Now, you know, basic structure of each test case.
+
+178
+00:12:24,000 --> 00:12:26,000
+Let's get closer to the technical part now.
+
+179
+00:12:27,000 --> 00:12:31,000
+The different libraries exist to write and run unit tests in Java.
+
+180
+00:12:31,000 --> 00:12:38,000
+When I say library, I'm in code that was already written, compiled and packed into the archive.
+
+181
+00:12:39,000 --> 00:12:44,000
+Today, we also are going to learn how to add these archives to our project to use code that wasn't
+
+182
+00:12:44,000 --> 00:12:45,000
+really written.
+
+183
+00:12:45,000 --> 00:12:53,000
+But first, let's review some of the library's J unit, probably the most popular library for unit testing
+
+184
+00:12:53,000 --> 00:12:54,000
+in Java.
+
+185
+00:12:54,000 --> 00:13:01,000
+And as a popular library for you, your testing is test and G Energy stands for new generation.
+
+186
+00:13:01,000 --> 00:13:06,000
+These two libraries are both similar and provides the same list of features.
+
+187
+00:13:06,000 --> 00:13:12,000
+You can make similar configurations, but in a different way in each of these libraries, with the exception
+
+188
+00:13:12,000 --> 00:13:16,000
+that testing over some more features that Gene doesn't have.
+
+189
+00:13:17,000 --> 00:13:20,000
+But in most cases, G unit is more popular for testing.
+
+190
+00:13:20,000 --> 00:13:26,000
+In my opinion, you'll learn some basic principles and we are going to run your unit first.
+
+191
+00:13:26,000 --> 00:13:31,000
+And after that it will be easier for you to apply this knowledge with other frameworks like Test and
+
+192
+00:13:31,000 --> 00:13:31,000
+G.
+
+193
+00:13:32,000 --> 00:13:36,000
+And this course, we're going to learn the latest based on today's version of the unit.
+
+194
+00:13:36,000 --> 00:13:41,000
+I'm talking about the unit version five that's also called Jupiter.
+
+195
+00:13:41,000 --> 00:13:47,000
+In case you use the unit for in your project, or probably a new version of the unit will be released
+
+196
+00:13:47,000 --> 00:13:48,000
+in the near future.
+
+197
+00:13:48,000 --> 00:13:51,000
+I would say that updates are not critical.
+
+198
+00:13:51,000 --> 00:13:56,000
+Moreover, core principles are the same in every framework for unit testing.
+
+199
+00:13:56,000 --> 00:14:02,000
+There might be specifics in the implementation of one or another method, a new version and probably
+
+200
+00:14:02,000 --> 00:14:04,000
+some new annotations or methods.
+
+201
+00:14:04,000 --> 00:14:08,000
+But again, it is not critical for understanding of the whole picture.
+
+202
+00:14:09,000 --> 00:14:12,000
+So don't worry and proceed with learning a unit.
+
+203
+00:14:12,000 --> 00:14:18,000
+On the example of the unit version five eight five consists of different modules.
+
+204
+00:14:18,000 --> 00:14:28,000
+Zaya Unit Platform Jupiter unit will touch the unit platform serves as a foundation for launch and testing
+
+205
+00:14:28,000 --> 00:14:30,000
+frameworks on the job of its own machine.
+
+206
+00:14:31,000 --> 00:14:37,000
+It also defines the Test Engine API for development, a test and framework that runs on the platform.
+
+207
+00:14:38,000 --> 00:14:45,000
+Also, the platform provides a console launcher to launch the platform from the command line Jupiter
+
+208
+00:14:45,000 --> 00:14:51,000
+in the combination of the new programming model and extension model for writing test and extensions.
+
+209
+00:14:51,000 --> 00:14:58,000
+In June five, the Jupiter project provides a test engine for running Jupiter based tests on the platform.
+
+210
+00:14:59,000 --> 00:15:07,000
+G20 provides a test engine for running June three and June four based tests on the platform, the different
+
+211
+00:15:07,000 --> 00:15:09,000
+API in different versions of the unit.
+
+212
+00:15:09,000 --> 00:15:13,000
+And this module enables the compatibility between different APIs.
+
+213
+00:15:14,000 --> 00:15:19,000
+In this course, we are going to learn the features of this powerful library on the real examples.
+
+214
+00:15:19,000 --> 00:15:25,000
+For this course, I'm going to use official documentation in real life, examples I will share with
+
+215
+00:15:25,000 --> 00:15:30,000
+you experience from my projects to help you learn best practices of writing unit tests.
+
+216
+00:15:30,000 --> 00:15:37,000
+Now I suggest jump directly to examples to help you understand technical part of your testing.
+
+217
+00:15:37,000 --> 00:15:40,000
+Let's create first simple class that we are going to test.
+
+218
+00:15:41,000 --> 00:15:45,000
+I created all classes before the lesson, but I will walk you through all of them.
+
+219
+00:15:45,000 --> 00:15:47,000
+Here is simple class calculator.
+
+220
+00:15:48,000 --> 00:15:51,000
+It contains one single method that performs addition.
+
+221
+00:15:51,000 --> 00:15:54,000
+As you can see, nothing special here.
+
+222
+00:15:54,000 --> 00:16:01,000
+Our main goal in this lesson to learn technical side of union task creation, usually for all tests,
+
+223
+00:16:01,000 --> 00:16:03,000
+separate source folder is created.
+
+224
+00:16:03,000 --> 00:16:04,000
+What do we need?
+
+225
+00:16:04,000 --> 00:16:05,000
+Separate source folder.
+
+226
+00:16:06,000 --> 00:16:12,000
+Because at the end of the day, you have to compile all your source code packet in one archive and deployed
+
+227
+00:16:12,000 --> 00:16:16,000
+on the web server or on it separately on the desktop.
+
+228
+00:16:16,000 --> 00:16:19,000
+And you don't need tests to make your code.
+
+229
+00:16:19,000 --> 00:16:24,000
+Now, units usually needed during the development, but not in production.
+
+230
+00:16:24,000 --> 00:16:32,000
+That's why I would love to test in the separate source folder to keep and track them separately when
+
+231
+00:16:32,000 --> 00:16:33,000
+we learn to.
+
+232
+00:16:33,000 --> 00:16:39,000
+And builds groups, you will see that it will be easy to separate source code of our program from the
+
+233
+00:16:39,000 --> 00:16:44,000
+source code of our tests, and we will not include tests in our final program archive.
+
+234
+00:16:45,000 --> 00:16:47,000
+It will help us to save some space and memory.
+
+235
+00:16:48,000 --> 00:16:53,000
+That's why the first thing you have to do on your computer is to create another source folder.
+
+236
+00:16:53,000 --> 00:16:55,000
+How to do this mouse right.
+
+237
+00:16:55,000 --> 00:17:02,000
+Click on your project, then select new and select folder write test here and create this folder by
+
+238
+00:17:02,000 --> 00:17:04,000
+present finish button.
+
+239
+00:17:04,000 --> 00:17:07,000
+I will not create this folder because I already created it.
+
+240
+00:17:08,000 --> 00:17:14,000
+The next thing I have to do is to tell the eclipse that I wanted to treat my new folder as a source
+
+241
+00:17:14,000 --> 00:17:14,000
+folder.
+
+242
+00:17:15,000 --> 00:17:19,000
+A source folder is marked by clips as containing Java sources.
+
+243
+00:17:19,000 --> 00:17:25,000
+Then when you compile your project, Eclipse will look for your source code into all your source folders.
+
+244
+00:17:26,000 --> 00:17:28,000
+You can make any folder become a source folder.
+
+245
+00:17:28,000 --> 00:17:31,000
+I didn't need to see Java build pass zazz.
+
+246
+00:17:31,000 --> 00:17:33,000
+Next time you compile your project.
+
+247
+00:17:33,000 --> 00:17:36,000
+Eclipse will also look for Java classes in that folder.
+
+248
+00:17:37,000 --> 00:17:39,000
+How to do this press mouse right.
+
+249
+00:17:39,000 --> 00:17:41,000
+Click on your test folder.
+
+250
+00:17:41,000 --> 00:17:48,000
+Hover over, build, pass and select use as a source folder and you can see that now this folder is
+
+251
+00:17:48,000 --> 00:17:53,000
+marked as a source folder and all Java sources inside will be compiled.
+
+252
+00:17:53,000 --> 00:17:57,000
+I already have here a lot of tests that test your homework.
+
+253
+00:17:58,000 --> 00:17:59,000
+I will not focus on them today.
+
+254
+00:18:00,000 --> 00:18:04,000
+Instead, we are going to create new test with you for our calculator.
+
+255
+00:18:04,000 --> 00:18:05,000
+I press mouse right.
+
+256
+00:18:05,000 --> 00:18:08,000
+Click on this folder and select new.
+
+257
+00:18:08,000 --> 00:18:10,000
+And here I click on the union test case.
+
+258
+00:18:11,000 --> 00:18:17,000
+The first thing that we have to understand that each test is a separate matter within the test class.
+
+259
+00:18:17,000 --> 00:18:22,000
+So creating a test case, we created a class where we will describe methods.
+
+260
+00:18:23,000 --> 00:18:28,000
+Usually test classes are placed in the same package as class that we want to test.
+
+261
+00:18:28,000 --> 00:18:33,000
+In our particular case, it is a package where we created the calculator class.
+
+262
+00:18:34,000 --> 00:18:40,000
+As you can see on the screen, it is the following package compatibles learning Java Core Jeanneret
+
+263
+00:18:40,000 --> 00:18:41,000
+five.
+
+264
+00:18:41,000 --> 00:18:45,000
+Let's write the package name in the relevant field in our results.
+
+265
+00:18:46,000 --> 00:18:48,000
+Now we have to give our class and name.
+
+266
+00:18:48,000 --> 00:18:54,000
+It is not a critical thing what name we are going to give, but it should be clear what class we are
+
+267
+00:18:54,000 --> 00:18:55,000
+going to test.
+
+268
+00:18:56,000 --> 00:18:58,000
+That's why let's call our new class.
+
+269
+00:18:58,000 --> 00:18:59,000
+Calculate the test.
+
+270
+00:19:00,000 --> 00:19:01,000
+Do not forget to select your unit.
+
+271
+00:19:01,000 --> 00:19:10,000
+Jupiter Test Radio button on the top here, press Finnish button and now you can see another popup eclipse
+
+272
+00:19:10,000 --> 00:19:16,000
+is smart enough to understand that we don't have Jupiter libraries in our class past and it will be
+
+273
+00:19:16,000 --> 00:19:19,000
+impossible to run tests without these libraries.
+
+274
+00:19:19,000 --> 00:19:23,000
+You can add unnecessary dependencies related to G and five.
+
+275
+00:19:23,000 --> 00:19:27,000
+Just keep selected as the last radio button from this list and press a button.
+
+276
+00:19:28,000 --> 00:19:30,000
+And here's our test is created.
+
+277
+00:19:30,000 --> 00:19:32,000
+So what was changed?
+
+278
+00:19:32,000 --> 00:19:34,000
+Let me show you mouse.
+
+279
+00:19:34,000 --> 00:19:34,000
+Right.
+
+280
+00:19:34,000 --> 00:19:40,000
+Click on any file in the project and select build pass configurability pass.
+
+281
+00:19:40,000 --> 00:19:42,000
+Go to library, stop.
+
+282
+00:19:42,000 --> 00:19:47,000
+And here on the class path, you can see all libraries that are added to your project.
+
+283
+00:19:47,000 --> 00:19:48,000
+Right now.
+
+284
+00:19:48,000 --> 00:19:53,000
+You can see that I will say that manually geoint for for some libraries.
+
+285
+00:19:53,000 --> 00:19:56,000
+I will explain in adolescence what do we need it for.
+
+286
+00:19:57,000 --> 00:20:00,000
+And there you can see that Unit five was added.
+
+287
+00:20:00,000 --> 00:20:06,000
+You can see that each file has Zha extension jar stands for Java Archive.
+
+288
+00:20:06,000 --> 00:20:09,000
+That is typical extension for the group of combined classes.
+
+289
+00:20:10,000 --> 00:20:15,000
+In case you would need to add your custom library to a project, you always can do it by present on
+
+290
+00:20:15,000 --> 00:20:22,000
+class first and after that press add external Jerse and here you will be able to specify the path to
+
+291
+00:20:22,000 --> 00:20:24,000
+the jars that you want to add.
+
+292
+00:20:25,000 --> 00:20:26,000
+That is simple.
+
+293
+00:20:26,000 --> 00:20:29,000
+Now let me close all these widgets.
+
+294
+00:20:29,000 --> 00:20:30,000
+Here is our test.
+
+295
+00:20:31,000 --> 00:20:38,000
+By default, if you impose here they are static methods from assertions class and previous version of
+
+296
+00:20:38,000 --> 00:20:45,000
+geo engineering information for there was an asset class with static methods that perform assertions.
+
+297
+00:20:46,000 --> 00:20:49,000
+And our second impulse is a test annotation.
+
+298
+00:20:49,000 --> 00:20:56,000
+This annotation is used to mock each test that should be performed separately as a single test specific
+
+299
+00:20:56,000 --> 00:20:59,000
+class that runs our test and the schools run their class.
+
+300
+00:21:00,000 --> 00:21:04,000
+It verifies all methods that have annotation test to run.
+
+301
+00:21:04,000 --> 00:21:10,000
+All test independently will learn different trainers and how they work in the following lessons.
+
+302
+00:21:11,000 --> 00:21:17,000
+After this annotation method is described in union documentation, you can see that each time they provide
+
+303
+00:21:17,000 --> 00:21:21,000
+a good example, they use default access modifier for methods.
+
+304
+00:21:22,000 --> 00:21:24,000
+Each test should avoid return type.
+
+305
+00:21:25,000 --> 00:21:31,000
+In this particular case, stop method was generated and it calls method from assertions class that fails
+
+306
+00:21:31,000 --> 00:21:32,000
+our test by the.
+
+307
+00:21:33,000 --> 00:21:37,000
+Let's create our test to verify that the Utian works as expected.
+
+308
+00:21:38,000 --> 00:21:43,000
+Let's create instance of our calculator type that is our build because of the test.
+
+309
+00:21:44,000 --> 00:21:48,000
+After that, let's go at MassArt and pass through there.
+
+310
+00:21:49,000 --> 00:21:55,000
+That is our operating path in the terms of build a separate check button will assign the value that
+
+311
+00:21:55,000 --> 00:21:58,000
+is returned from this method to actual end variable.
+
+312
+00:21:59,000 --> 00:22:02,000
+And now the final part of our test.
+
+313
+00:22:02,000 --> 00:22:08,000
+It is chequerboard during the course we are going to run different assertions that will help you to
+
+314
+00:22:08,000 --> 00:22:14,000
+perform verifications, majority of them from assertions class that we imparted on the top of our file.
+
+315
+00:22:15,000 --> 00:22:21,000
+I call a service equals method to compare expected and actual values I expect expected where we first
+
+316
+00:22:22,000 --> 00:22:24,000
+and after that I pass actual value.
+
+317
+00:22:25,000 --> 00:22:26,000
+In the case they will be equal.
+
+318
+00:22:27,000 --> 00:22:30,000
+Test will pass in case they won't be equal.
+
+319
+00:22:30,000 --> 00:22:31,000
+Test will fail.
+
+320
+00:22:32,000 --> 00:22:33,000
+Let's run our tests.
+
+321
+00:22:33,000 --> 00:22:37,000
+I press control and F eleven together to run the tests.
+
+322
+00:22:37,000 --> 00:22:42,000
+And here you can find specific gene to you to check result of our tests.
+
+323
+00:22:42,000 --> 00:22:49,000
+I can see that my tests successfully passed in case expected value won't be equal to actual.
+
+324
+00:22:49,000 --> 00:22:52,000
+The test would fail just for the sake of the demo.
+
+325
+00:22:52,000 --> 00:22:54,000
+Let me change five to six here.
+
+326
+00:22:54,000 --> 00:22:55,000
+As expected.
+
+327
+00:22:55,000 --> 00:23:02,000
+The result I run test again and you can see assertion failed error expected six but was five.
+
+328
+00:23:03,000 --> 00:23:07,000
+That's how you can customize data input to test different cases.
+
+329
+00:23:07,000 --> 00:23:08,000
+Congratulations.
+
+330
+00:23:09,000 --> 00:23:11,000
+We have just written your first union test.
+
+331
+00:23:11,000 --> 00:23:15,000
+We still have a lot of things to learn, but we already wrote our first test.
+
+332
+00:23:16,000 --> 00:23:18,000
+We learned a lot for the day.
+
+333
+00:23:18,000 --> 00:23:24,000
+So I suggest the recap what we have learned in this lesson in pursuit with more information in the next
+
+334
+00:23:24,000 --> 00:23:24,000
+lessons.
+
+335
+00:23:25,000 --> 00:23:29,000
+Today, we learned what union testing is you learned in test rules.
+
+336
+00:23:30,000 --> 00:23:35,000
+Also in this lesson, I explained to you what first principles are now.
+
+337
+00:23:35,000 --> 00:23:41,000
+You know, the basic structure of your test review, such patterns as built operate check three eight.
+
+338
+00:23:41,000 --> 00:23:48,000
+And given that, I hold an overview of two, the most popular libraries for unit testing in Java.
+
+339
+00:23:48,000 --> 00:23:52,000
+After that, we dive into the details of the unit.
+
+340
+00:23:52,000 --> 00:23:58,000
+You learn how to enable JI, you support an eclipse and we roll to your first test.
+
+341
+00:23:59,000 --> 00:24:00,000
+That's all for this lesson.
+
+342
+00:24:00,000 --> 00:24:02,000
+Thanks a lot for your attention.
+
+343
+00:24:02,000 --> 00:24:04,000
+See you in the next lesson.
+

34 - Unit Testing & JUnit 5/002 JUnit 5 examples VS JUnit 4 + Equivalence class partitioning_en.srt

@@ -0,0 +1,1144 @@
+1
+00:00:06,000 --> 00:00:11,000
+Hello, yes, students in this lesson, we are going to dive into specifics of the unique library and
+
+2
+00:00:11,000 --> 00:00:15,000
+learn the Unit API by this lesson, you already know what unit testing is.
+
+3
+00:00:15,000 --> 00:00:18,000
+You also know basic principles of unit testing.
+
+4
+00:00:18,000 --> 00:00:24,000
+So in this lesson, we'll focus our attention on tools and APIs that is provided by the unit to help
+
+5
+00:00:24,000 --> 00:00:26,000
+us create reliable use of tests.
+
+6
+00:00:27,000 --> 00:00:34,000
+We'll learn specifics of Unit five and compared with Unit four, because even now in G four is very
+
+7
+00:00:34,000 --> 00:00:39,000
+popular and Unit five has modules that helps us to run tests that are written.
+
+8
+00:00:39,000 --> 00:00:40,000
+What do you need for?
+
+9
+00:00:40,000 --> 00:00:46,000
+That's why knowing specifics of both libraries is important, in my opinion, in this class.
+
+10
+00:00:46,000 --> 00:00:51,000
+And we are going to learn how to declare an assets in a unit that will help us to set up environment
+
+11
+00:00:51,000 --> 00:00:57,000
+for execution of each test case and clean up environment after each test case execution during this
+
+12
+00:00:57,000 --> 00:00:58,000
+class.
+
+13
+00:00:58,000 --> 00:01:02,000
+And I'll show your code examples and we'll cover specific code with tests.
+
+14
+00:01:03,000 --> 00:01:10,000
+You will learn how to use test annotation also on equivalence class partitioning technique on real examples.
+
+15
+00:01:10,000 --> 00:01:17,000
+You see how it can help us to save time and write tests that really helps us to test all possible test
+
+16
+00:01:17,000 --> 00:01:17,000
+cases.
+
+17
+00:01:18,000 --> 00:01:23,000
+And at the end of the lesson, I'll show you how to test exceptions, which you we have a lot of things
+
+18
+00:01:23,000 --> 00:01:25,000
+to learn in this lesson.
+
+19
+00:01:25,000 --> 00:01:28,000
+We are going to have a lot of coding examples and live demo.
+
+20
+00:01:28,000 --> 00:01:35,000
+So let's start first of all, I want to highlight you source of information to learn your unit always
+
+21
+00:01:35,000 --> 00:01:38,000
+rely only on official documentation.
+
+22
+00:01:38,000 --> 00:01:44,000
+Information and books may be not relevant information and some tutorials may not contain all the details
+
+23
+00:01:44,000 --> 00:01:45,000
+and specifics.
+
+24
+00:01:45,000 --> 00:01:50,000
+So knowing where official documentation is located is always useful.
+
+25
+00:01:50,000 --> 00:01:52,000
+I will leave this link and attachments to the video.
+
+26
+00:01:53,000 --> 00:01:55,000
+But let me also make a brief overview here.
+
+27
+00:01:55,000 --> 00:01:57,000
+You can see a list of all modules.
+
+28
+00:01:57,000 --> 00:02:01,000
+As we keep learning a unit, you will gradually learn all of these.
+
+29
+00:02:01,000 --> 00:02:04,000
+We can explore each module by clicking on it.
+
+30
+00:02:04,000 --> 00:02:11,000
+If you remember in previous lesson we wrote our first unit test and we used as equals message from assertions
+
+31
+00:02:11,000 --> 00:02:11,000
+class.
+
+32
+00:02:12,000 --> 00:02:15,000
+Let's find this class and learn what other methods allocated there.
+
+33
+00:02:16,000 --> 00:02:23,000
+To find assertions class, just click on org unit Jupiter API module after choose or GIULIAN Jupiter
+
+34
+00:02:23,000 --> 00:02:24,000
+API package.
+
+35
+00:02:24,000 --> 00:02:29,000
+And here you can find a list of interfaces and list of classes from this package.
+
+36
+00:02:30,000 --> 00:02:31,000
+Here is our sessions class.
+
+37
+00:02:32,000 --> 00:02:33,000
+Let's open it.
+
+38
+00:02:33,000 --> 00:02:35,000
+And here is a full list of matches.
+
+39
+00:02:35,000 --> 00:02:39,000
+You can click on any method that is interesting for you to learn documentation.
+
+40
+00:02:40,000 --> 00:02:46,000
+How this example helps you understand how you can find documentation by using module, name, package,
+
+41
+00:02:46,000 --> 00:02:47,000
+name and class name.
+
+42
+00:02:47,000 --> 00:02:51,000
+So and he Sampson will remain clear even after today's lesson.
+
+43
+00:02:51,000 --> 00:02:54,000
+You can always open documentation to read it.
+
+44
+00:02:54,000 --> 00:02:55,000
+Let's proceed.
+
+45
+00:02:55,000 --> 00:02:57,000
+I open Eclipse.
+
+46
+00:02:57,000 --> 00:03:02,000
+I suggest to learn the first two classes that we are going to cover with test today.
+
+47
+00:03:02,000 --> 00:03:05,000
+We have class with name mining transaction service.
+
+48
+00:03:05,000 --> 00:03:07,000
+It has one method to transfer money.
+
+49
+00:03:08,000 --> 00:03:12,000
+This method takes two accounts as arguments they account from.
+
+50
+00:03:13,000 --> 00:03:20,000
+That is from where money should be sent an account to this is where money should be sent and amount
+
+51
+00:03:20,000 --> 00:03:20,000
+of money to send.
+
+52
+00:03:21,000 --> 00:03:23,000
+Let me show you the source code of account.
+
+53
+00:03:23,000 --> 00:03:29,000
+Class account is a separate class that is located in the same package with current example.
+
+54
+00:03:29,000 --> 00:03:32,000
+For the sake of the damos, it contains only one field default.
+
+55
+00:03:32,000 --> 00:03:35,000
+Constructor and constructor was one argument.
+
+56
+00:03:35,000 --> 00:03:38,000
+Additionally, we have getters and setters here.
+
+57
+00:03:38,000 --> 00:03:39,000
+That's it.
+
+58
+00:03:39,000 --> 00:03:44,000
+Let's get back now to mining transaction service here and transfer money.
+
+59
+00:03:44,000 --> 00:03:46,000
+Massata, you can see if few cheques.
+
+60
+00:03:46,000 --> 00:03:52,000
+It is important to understand the logic of the method to be able to write a test for it in case account
+
+61
+00:03:52,000 --> 00:03:59,000
+from our account is now we through legal argument, exception with this message in case money amount
+
+62
+00:03:59,000 --> 00:04:06,000
+is less or equal to zero withdrawal illegal argument exception but with different error message in case
+
+63
+00:04:06,000 --> 00:04:12,000
+account from doesn't have enough money for this transaction, we throw our custom exception, not enough
+
+64
+00:04:12,000 --> 00:04:13,000
+money exception.
+
+65
+00:04:14,000 --> 00:04:18,000
+And only after all these checks we can perform a transaction.
+
+66
+00:04:18,000 --> 00:04:24,000
+We decrease amount of money for our account from and we increase amount of money for account to and
+
+67
+00:04:24,000 --> 00:04:27,000
+we return true in case transaction is successful.
+
+68
+00:04:28,000 --> 00:04:31,000
+The simple example that is really close to real life case.
+
+69
+00:04:31,000 --> 00:04:34,000
+And today we are going to cover this unit with units.
+
+70
+00:04:35,000 --> 00:04:37,000
+Let's start from previous lesson.
+
+71
+00:04:37,000 --> 00:04:41,000
+You already know that it is recommended to create test in the separate source folder.
+
+72
+00:04:42,000 --> 00:04:48,000
+I already created this test before the lesson to save time during the year I called this test class
+
+73
+00:04:48,000 --> 00:04:49,000
+money transaction service test.
+
+74
+00:04:49,000 --> 00:04:52,000
+I will walk you through each line one by one.
+
+75
+00:04:53,000 --> 00:04:56,000
+First of all, I declare a field in my test class.
+
+76
+00:04:56,000 --> 00:05:02,000
+This field has type of unit that we are going to test my transaction service I call variable test.
+
+77
+00:05:02,000 --> 00:05:08,000
+For instance, I have to initialize it, don't pay attention to these concerns right now, you will
+
+78
+00:05:08,000 --> 00:05:11,000
+understand a little bit later in this lesson, why do we need them?
+
+79
+00:05:12,000 --> 00:05:16,000
+Usually we create a special message that will be executed before each test.
+
+80
+00:05:16,000 --> 00:05:18,000
+That's why it is important.
+
+81
+00:05:19,000 --> 00:05:23,000
+You remember first principles, each test should be isolated from another.
+
+82
+00:05:24,000 --> 00:05:26,000
+That's why it is important that you're in each test.
+
+83
+00:05:26,000 --> 00:05:31,000
+I create a new instance of mining transaction service because potentially this object may have some
+
+84
+00:05:31,000 --> 00:05:37,000
+states that will be adjusted by one test and that will impact on the execution of another test.
+
+85
+00:05:38,000 --> 00:05:46,000
+This special method has annotation before each annotations and that information for unit, namely for
+
+86
+00:05:46,000 --> 00:05:53,000
+the class that is going to execute our tests is a group of classes that executes test called runners.
+
+87
+00:05:53,000 --> 00:05:58,000
+The runner will verify what method and class has before each annotation.
+
+88
+00:05:58,000 --> 00:06:06,000
+It will memorize it and will run this method before each test method in for there was a similar notation
+
+89
+00:06:06,000 --> 00:06:06,000
+before.
+
+90
+00:06:07,000 --> 00:06:14,000
+As you can see, there is no big difference between Unit four and five so far in this method, I initialize
+
+91
+00:06:14,000 --> 00:06:17,000
+my test instance usually common configurations.
+
+92
+00:06:17,000 --> 00:06:22,000
+It is important for each test is placed in this method, but we have only one line.
+
+93
+00:06:23,000 --> 00:06:26,000
+Pay attention that this method has what return type?
+
+94
+00:06:26,000 --> 00:06:32,000
+You can name this method as you wish, but I usually name it set up in the unit.
+
+95
+00:06:32,000 --> 00:06:36,000
+We also can configure methods that will be executed after each test.
+
+96
+00:06:36,000 --> 00:06:41,000
+This method has annotation after each injury unit five and after injury unit four.
+
+97
+00:06:42,000 --> 00:06:46,000
+In our particular case, there is no need to perform any actions after each test.
+
+98
+00:06:46,000 --> 00:06:48,000
+But you can clean up something.
+
+99
+00:06:48,000 --> 00:06:53,000
+What was done by your test to stay aligned with repeatable and isolated principles?
+
+100
+00:06:53,000 --> 00:07:00,000
+There are also two specific annotations that allows us to execute specific code before all test methods
+
+101
+00:07:00,000 --> 00:07:06,000
+and after all, test matches we can create Masset and market was before all annotation.
+
+102
+00:07:06,000 --> 00:07:13,000
+This method will be executed before all test methods pay attention to this method has static modifier
+
+103
+00:07:13,000 --> 00:07:17,000
+in case you use it for you can use before class annotation.
+
+104
+00:07:18,000 --> 00:07:21,000
+Similar to this annotation, we have another one.
+
+105
+00:07:21,000 --> 00:07:28,000
+Marcu static method was, after all, annotation and this method will be executed after all test methods
+
+106
+00:07:28,000 --> 00:07:32,000
+in unit four you can use after class annotation instead.
+
+107
+00:07:32,000 --> 00:07:35,000
+To be honest, these cases are very specific.
+
+108
+00:07:35,000 --> 00:07:36,000
+Why?
+
+109
+00:07:36,000 --> 00:07:39,000
+Because you want to isolate each test case from Annisa.
+
+110
+00:07:40,000 --> 00:07:45,000
+That's why performing some specific action before running all test cases and some method only.
+
+111
+00:07:45,000 --> 00:07:50,000
+After all test cases means that all test cases have something in common.
+
+112
+00:07:50,000 --> 00:07:55,000
+While this could be the case, sometimes this is very rare based on my experience.
+
+113
+00:07:56,000 --> 00:08:02,000
+So remember, use annotations and use them when you need, but most likely before each and after each
+
+114
+00:08:02,000 --> 00:08:04,000
+will be enough for you in most cases.
+
+115
+00:08:05,000 --> 00:08:07,000
+Let's move on now.
+
+116
+00:08:07,000 --> 00:08:08,000
+Let's write test.
+
+117
+00:08:08,000 --> 00:08:12,000
+Each test is a separate method that is marked with annotation test.
+
+118
+00:08:13,000 --> 00:08:17,000
+Each test method has void's return type in June five.
+
+119
+00:08:17,000 --> 00:08:22,000
+It is important the test method has any access modifier that is not private in unit four.
+
+120
+00:08:23,000 --> 00:08:27,000
+It is important the test method should have public access modifier.
+
+121
+00:08:27,000 --> 00:08:28,000
+That is model changed.
+
+122
+00:08:28,000 --> 00:08:31,000
+But still this is worse to mention in my opinion.
+
+123
+00:08:32,000 --> 00:08:38,000
+As you remember, it is important to give meaningful names to our tests to make sure that everyone understands
+
+124
+00:08:38,000 --> 00:08:39,000
+what this method is about.
+
+125
+00:08:40,000 --> 00:08:46,000
+Some tutors and tutorials that teach you to test methods also teach you how to make masses in case with
+
+126
+00:08:46,000 --> 00:08:49,000
+test transfer money method we have to write transfer money test.
+
+127
+00:08:50,000 --> 00:08:53,000
+In other words, just a test suffix at the end of the method.
+
+128
+00:08:54,000 --> 00:09:00,000
+But in my opinion, it is more important to not just make sure that you have a test for some specific
+
+129
+00:09:00,000 --> 00:09:00,000
+method.
+
+130
+00:09:00,000 --> 00:09:05,000
+I would rather prefer to make sure that method behaves in the way I expect it behaves.
+
+131
+00:09:06,000 --> 00:09:08,000
+And I want to reflect this in Masaomi.
+
+132
+00:09:09,000 --> 00:09:14,000
+That's why I recommend you to make sure that method names are named after expected behavior.
+
+133
+00:09:15,000 --> 00:09:21,000
+Always remember that your tests are documentation, just telling this documentation what your test unit
+
+134
+00:09:21,000 --> 00:09:27,000
+should be able to do and how it should behave in case how a unit should be able to transfer money.
+
+135
+00:09:27,000 --> 00:09:33,000
+Let's call this method and this way should transfer money from one account to another.
+
+136
+00:09:33,000 --> 00:09:39,000
+That's why one of the ways to name your methods is to start name it from should word and describe what
+
+137
+00:09:39,000 --> 00:09:41,000
+your unit should be able to do.
+
+138
+00:09:41,000 --> 00:09:43,000
+This makes things clearer, don't you think?
+
+139
+00:09:43,000 --> 00:09:46,000
+So now let's explore the test itself.
+
+140
+00:09:47,000 --> 00:09:48,000
+I write test accordingly.
+
+141
+00:09:48,000 --> 00:09:51,000
+Even when then partan we have two accounts.
+
+142
+00:09:52,000 --> 00:09:55,000
+Pay attention that I don't have any magic numbers in my code.
+
+143
+00:09:55,000 --> 00:10:00,000
+Instead, I declare constants that clearly describe what this value for.
+
+144
+00:10:00,000 --> 00:10:02,000
+For example, in my test I have.
+
+145
+00:10:02,000 --> 00:10:08,000
+We have some random value for amount of money, and that's why I called this constant in the same way
+
+146
+00:10:08,000 --> 00:10:13,000
+random money amount in case this is zero, I call it zero my amount.
+
+147
+00:10:14,000 --> 00:10:21,000
+Here's one note samples for static analysis doesn't three zero and one will use as magic numbers because
+
+148
+00:10:21,000 --> 00:10:27,000
+usually it is clear when you use zero and one, it is not so confusing as using another numbers.
+
+149
+00:10:27,000 --> 00:10:34,000
+For example, in case you used zero, it is clear that you use to zero to zero money amount for a count.
+
+150
+00:10:35,000 --> 00:10:42,000
+But in case you use three, it is not clear why you use three, but not five and not 10.
+
+151
+00:10:42,000 --> 00:10:46,000
+Can you understand now what our magic numbers but still in tests?
+
+152
+00:10:47,000 --> 00:10:51,000
+I prefer to give a name even to zero and one values is that's my style.
+
+153
+00:10:52,000 --> 00:10:53,000
+But you can decide and choose.
+
+154
+00:10:53,000 --> 00:10:57,000
+Your next part of the method is my when part.
+
+155
+00:10:58,000 --> 00:11:02,000
+I want to execute method I pass to accounts there and money amount.
+
+156
+00:11:02,000 --> 00:11:08,000
+I know that this money amount is valid money amount because I created the first account with such my
+
+157
+00:11:08,000 --> 00:11:09,000
+amount.
+
+158
+00:11:09,000 --> 00:11:14,000
+So I know that my transaction should be successful and my test should pass.
+
+159
+00:11:14,000 --> 00:11:21,000
+Now I have final part of my test that is a certain part and this is the case when I can perform two
+
+160
+00:11:21,000 --> 00:11:27,000
+assertions in one test because two assertions are connected with a single concept.
+
+161
+00:11:27,000 --> 00:11:33,000
+I have to verify that amount of money is decreased to zero on the first account and the amount of money
+
+162
+00:11:33,000 --> 00:11:35,000
+is increased on the second account.
+
+163
+00:11:35,000 --> 00:11:37,000
+That's why I have these two assertions.
+
+164
+00:11:37,000 --> 00:11:43,000
+In one test case, I use a service equals method and plus expected and actual value to it.
+
+165
+00:11:44,000 --> 00:11:49,000
+You already know this assertion from previous lesson, so nothing special here.
+
+166
+00:11:49,000 --> 00:11:56,000
+Now let me run this test one more time in case you work in Eclipse and you want to execute only one
+
+167
+00:11:56,000 --> 00:11:59,000
+single test, but not all tests from the class.
+
+168
+00:12:00,000 --> 00:12:04,000
+Make sure that your cursor is near the test method name, for example.
+
+169
+00:12:04,000 --> 00:12:05,000
+Here is my cursor.
+
+170
+00:12:05,000 --> 00:12:06,000
+Can I see it?
+
+171
+00:12:06,000 --> 00:12:08,000
+You can run test by pressing the mouse, right?
+
+172
+00:12:08,000 --> 00:12:11,000
+Click and choose and run as a unit test.
+
+173
+00:12:11,000 --> 00:12:15,000
+But I love to use shortcuts and now I press control and f eleven.
+
+174
+00:12:16,000 --> 00:12:23,000
+And here in test results you can see that only one method was executed and it passed in case I have
+
+175
+00:12:23,000 --> 00:12:31,000
+cursor placed in any other place and I press control and then all tests are executed and then test results.
+
+176
+00:12:31,000 --> 00:12:33,000
+Now you can see more than one test.
+
+177
+00:12:33,000 --> 00:12:34,000
+Is that clear?
+
+178
+00:12:35,000 --> 00:12:41,000
+So my test passed as I expected, but in this specific case, I still won't be happy.
+
+179
+00:12:42,000 --> 00:12:49,000
+My experience tells me that I shouldn't believe to the test that I have never seen Rat or in other words,
+
+180
+00:12:49,000 --> 00:12:49,000
+failed.
+
+181
+00:12:50,000 --> 00:12:50,000
+Why?
+
+182
+00:12:51,000 --> 00:12:57,000
+Because there are some cases when you run the test and it is green and you are happy, but when some
+
+183
+00:12:57,000 --> 00:13:03,000
+defect is popped up, you are wondering why unit test was not failed and you learn that your test is
+
+184
+00:13:03,000 --> 00:13:07,000
+never rat, even when you specify wrong expected value.
+
+185
+00:13:08,000 --> 00:13:14,000
+Not delving into the details right now, but it could be that you wrote your test that is always passed
+
+186
+00:13:14,000 --> 00:13:16,000
+because you missed some minor detail.
+
+187
+00:13:16,000 --> 00:13:23,000
+That's why writing test first is good, because you are always sure that you saw this test firing and
+
+188
+00:13:23,000 --> 00:13:24,000
+you saw this test passed.
+
+189
+00:13:25,000 --> 00:13:31,000
+My advices in case you write your test after you already wrote the code, just spent two more seconds
+
+190
+00:13:31,000 --> 00:13:34,000
+to test it with some invalid expected value.
+
+191
+00:13:34,000 --> 00:13:37,000
+For example, here, unexpected value.
+
+192
+00:13:37,000 --> 00:13:40,000
+I would specify some random value and will run the test one more time.
+
+193
+00:13:41,000 --> 00:13:45,000
+Now I see the test has failed and I can be calm and sleep well.
+
+194
+00:13:45,000 --> 00:13:51,000
+My test is useful and it will tell me in case something will go wrong during the transaction, I will
+
+195
+00:13:51,000 --> 00:13:55,000
+return the valid expected value and will proceed with the next test.
+
+196
+00:13:55,000 --> 00:14:01,000
+I want to ask you interesting question that I always ask during the interview when I want to verify
+
+197
+00:14:01,000 --> 00:14:03,000
+whether a person can write test efficiently.
+
+198
+00:14:04,000 --> 00:14:08,000
+The question is how you can be sure that you wrote enough tests.
+
+199
+00:14:09,000 --> 00:14:15,000
+For example, we test my transaction with some random well, you this when the value is equal to the
+
+200
+00:14:15,000 --> 00:14:18,000
+amount of money on the account before money transaction.
+
+201
+00:14:18,000 --> 00:14:22,000
+How many more tests will you write when you arrive now?
+
+202
+00:14:22,000 --> 00:14:25,000
+Test with transferring money was another random value.
+
+203
+00:14:25,000 --> 00:14:30,000
+Or you would said twice as much money on the account and you would transfer only half of the money.
+
+204
+00:14:31,000 --> 00:14:37,000
+Would this test have sense and do you need to write it or no press pause and take a minute to think
+
+205
+00:14:37,000 --> 00:14:38,000
+about this question.
+
+206
+00:14:38,000 --> 00:14:39,000
+How would you answer?
+
+207
+00:14:40,000 --> 00:14:44,000
+I expect to hear that you know what equivalence class position is?
+
+208
+00:14:45,000 --> 00:14:46,000
+What is this?
+
+209
+00:14:46,000 --> 00:14:51,000
+This is software testing technique that divides the input data of a software unit.
+
+210
+00:14:51,000 --> 00:14:57,000
+Interpretations of equivalent data from each test cases can be derived in principle.
+
+211
+00:14:57,000 --> 00:15:02,000
+Test cases are designed to cover each partition at least once this.
+
+212
+00:15:03,000 --> 00:15:10,000
+Tries to define test cases that uncover clusters of errors, thereby reducing the total number of test
+
+213
+00:15:10,000 --> 00:15:16,000
+cases that must be developed, an advantage of this approach is a reduction in the time required for
+
+214
+00:15:16,000 --> 00:15:21,000
+testing software use the less number of test cases, how to apply this knowledge while writing unit
+
+215
+00:15:22,000 --> 00:15:24,000
+tests before writing any sort of test.
+
+216
+00:15:24,000 --> 00:15:28,000
+Sit down and think about all possible inputs to your method.
+
+217
+00:15:29,000 --> 00:15:34,000
+Group these inputs and write test for only one example of data input from each group.
+
+218
+00:15:35,000 --> 00:15:37,000
+How to apply this knowledge in our example.
+
+219
+00:15:37,000 --> 00:15:43,000
+Let me show you, for example, the need to write test the test transaction of another positive money
+
+220
+00:15:43,000 --> 00:15:44,000
+amount.
+
+221
+00:15:44,000 --> 00:15:47,000
+No, because one hundred that is our end.
+
+222
+00:15:47,000 --> 00:15:52,000
+The value is the same as 50, the same as 20, all in the same equivalence class.
+
+223
+00:15:53,000 --> 00:15:58,000
+These are all numbers that are greater than or equal to the amount of money that are currently on the
+
+224
+00:15:58,000 --> 00:15:59,000
+account.
+
+225
+00:15:59,000 --> 00:16:01,000
+Number one, by the way.
+
+226
+00:16:01,000 --> 00:16:03,000
+Let me switch to the implementation class.
+
+227
+00:16:03,000 --> 00:16:04,000
+Can I see this?
+
+228
+00:16:04,000 --> 00:16:11,000
+If class I check was a money amount to transfer is no more than the current amount of money on the account.
+
+229
+00:16:12,000 --> 00:16:15,000
+That means we defined our first equivalence class.
+
+230
+00:16:15,000 --> 00:16:16,000
+Is that clear?
+
+231
+00:16:17,000 --> 00:16:22,000
+And that is how this technique can help us to save time by writing less number of tests.
+
+232
+00:16:22,000 --> 00:16:27,000
+But at the same time, be sure that we have a set of tests that will secure us.
+
+233
+00:16:27,000 --> 00:16:33,000
+Let's now proceed with defining our next set of data for testing based on our source code.
+
+234
+00:16:33,000 --> 00:16:36,000
+We also know that there are different conditions.
+
+235
+00:16:36,000 --> 00:16:39,000
+One exception is thrown our next Test match.
+
+236
+00:16:39,000 --> 00:16:42,000
+It sounds like this should throw exception.
+
+237
+00:16:42,000 --> 00:16:49,000
+If I count from is now my great first account variable that is referencing to now I create the second
+
+238
+00:16:49,000 --> 00:16:53,000
+account and now I call another method from assertions class.
+
+239
+00:16:53,000 --> 00:16:55,000
+The method is called asserts rules.
+
+240
+00:16:56,000 --> 00:17:02,000
+This method verifies that the US exceptions of specific type of identification of some method.
+
+241
+00:17:02,000 --> 00:17:05,000
+The test will pass only in case error of this type.
+
+242
+00:17:05,000 --> 00:17:07,000
+In our case, this is a legal argument.
+
+243
+00:17:07,000 --> 00:17:09,000
+The exception is wrong.
+
+244
+00:17:09,000 --> 00:17:12,000
+In case there were no exception or was the exception of another type.
+
+245
+00:17:13,000 --> 00:17:17,000
+The test will be failed, asserts Rose, takes two arguments.
+
+246
+00:17:17,000 --> 00:17:23,000
+The first argument is a class of expected exception, and the second argument is a function that will
+
+247
+00:17:23,000 --> 00:17:24,000
+execute any MassArt unit.
+
+248
+00:17:25,000 --> 00:17:28,000
+Usually we describe this with the help of lambda expression.
+
+249
+00:17:28,000 --> 00:17:31,000
+As you can see, I call transfer money method from lambda function.
+
+250
+00:17:32,000 --> 00:17:33,000
+Does it make sense?
+
+251
+00:17:33,000 --> 00:17:36,000
+One more interesting thing to note here.
+
+252
+00:17:36,000 --> 00:17:40,000
+Let me open the source code of our class that we are testing, if you remember.
+
+253
+00:17:40,000 --> 00:17:47,000
+And our method was a legal argument, exception in three cases when I count from is now when I count
+
+254
+00:17:47,000 --> 00:17:51,000
+two is now and when the money amount to transfer is less than or equal to zero.
+
+255
+00:17:52,000 --> 00:17:58,000
+How to understand when I get exceptional because of invalid account argument or because of invalid money
+
+256
+00:17:58,000 --> 00:18:03,000
+amount argument, especially for this I used messages in exceptions.
+
+257
+00:18:03,000 --> 00:18:09,000
+Let's get back to our test, asserts Rosmus returns the reference to exception object.
+
+258
+00:18:09,000 --> 00:18:12,000
+I can capture it and assign a variable.
+
+259
+00:18:12,000 --> 00:18:16,000
+The next thing that I will do, I will check that message of exception.
+
+260
+00:18:16,000 --> 00:18:20,000
+Exactly the message that I expect to have now.
+
+261
+00:18:20,000 --> 00:18:23,000
+I can be sure, as it indicates this assertion will pass.
+
+262
+00:18:23,000 --> 00:18:30,000
+That would mean that I received exactly the legal argument exception that I expected that it makes sense
+
+263
+00:18:30,000 --> 00:18:31,000
+in for.
+
+264
+00:18:31,000 --> 00:18:37,000
+You had an opportunity to specify type of expected exception, your test annotation just like this.
+
+265
+00:18:37,000 --> 00:18:43,000
+You write expected words in parentheses and specify class of exception that you expect.
+
+266
+00:18:43,000 --> 00:18:49,000
+You can see that in this case, I use annotation from another package that is used for package.
+
+267
+00:18:50,000 --> 00:18:56,000
+I show that just for the sake of the example, how to test similar case in unit for the next test case
+
+268
+00:18:56,000 --> 00:18:58,000
+is similar to the current one.
+
+269
+00:18:58,000 --> 00:19:01,000
+We just test the same in case account two is now.
+
+270
+00:19:02,000 --> 00:19:03,000
+What are the cases we have?
+
+271
+00:19:04,000 --> 00:19:09,000
+We also thrown out enough money exception in case we want to transfer more monies and we actually have
+
+272
+00:19:10,000 --> 00:19:16,000
+we have test to verify exception in case we try to send negative money amount and the same error in
+
+273
+00:19:16,000 --> 00:19:17,000
+case we want to transfer zero.
+
+274
+00:19:18,000 --> 00:19:21,000
+Now, it looks like we tested all possible cases.
+
+275
+00:19:22,000 --> 00:19:23,000
+We learned a lot for today.
+
+276
+00:19:23,000 --> 00:19:27,000
+Let's recap what we have learned today in this lesson.
+
+277
+00:19:27,000 --> 00:19:31,000
+We learned where to find union documentation and how to use it.
+
+278
+00:19:31,000 --> 00:19:37,000
+We learned annotations that will help us to set up an environment before each test and clean up environment
+
+279
+00:19:37,000 --> 00:19:39,000
+after each test execution.
+
+280
+00:19:39,000 --> 00:19:43,000
+During the lesson, we compared how to do the same things with Unit five.
+
+281
+00:19:43,000 --> 00:19:48,000
+Indeed four, we learned test annotation and you understood how to create a test case.
+
+282
+00:19:49,000 --> 00:19:53,000
+You learned what equivalence test partitioning and how to use this technique.
+
+283
+00:19:53,000 --> 00:19:59,000
+And at the end of the lesson we learned how to test exceptions in and hope this lesson was interesting
+
+284
+00:19:59,000 --> 00:20:00,000
+for you.
+
+285
+00:20:00,000 --> 00:20:02,000
+Thanks a lot for your attention.
+
+286
+00:20:02,000 --> 00:20:04,000
+Have a great day and see you in the next lesson.
+

34 - Unit Testing & JUnit 5/002 JUnit-Documentation.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://junit.org/junit5/docs/current/api/

34 - Unit Testing & JUnit 5/002 Source-code-of-MoneyTransactionService.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/junit5/MoneyTransactionService.java

34 - Unit Testing & JUnit 5/002 Source-code-of-MoneyTransactionServiceTest.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/test/com/itbulls/learnit/javacore/junit5/MoneyTransactionServiceTest.java

34 - Unit Testing & JUnit 5/003 JUnit 5 API (Advanced) & Test Code Coverage_en.srt

@@ -0,0 +1,1128 @@
+1
+00:00:05,000 --> 00:00:11,000
+Hello, dear students, in this lesson, we are going to proceed learning API will learn new annotations
+
+2
+00:00:11,000 --> 00:00:13,000
+that will use to configure our tests.
+
+3
+00:00:13,000 --> 00:00:19,000
+Yet I will show you on examples how the display name annotation helps us to make our test reports more
+
+4
+00:00:19,000 --> 00:00:20,000
+readable.
+
+5
+00:00:20,000 --> 00:00:27,000
+Also, we'll learn how to display name generation notation to help us improve our test report automatically
+
+6
+00:00:27,000 --> 00:00:28,000
+during the class.
+
+7
+00:00:28,000 --> 00:00:32,000
+And we'll talk about API that will help us to group assertions together.
+
+8
+00:00:32,000 --> 00:00:39,000
+Besides that, you'll learn how to create dependent assertions in some cases in real life that in case
+
+9
+00:00:39,000 --> 00:00:46,000
+requirements for test conditions are not met, there is no sense to verify other things and will learn
+
+10
+00:00:46,000 --> 00:00:47,000
+how to configure this flow.
+
+11
+00:00:48,000 --> 00:00:53,000
+Also, I will show you to the powerful mechanism of assumptions and how it works.
+
+12
+00:00:53,000 --> 00:00:58,000
+After that, we'll dive deeper and will learn how to create parametrized tests.
+
+13
+00:00:58,000 --> 00:01:03,000
+And at the end of the lesson, I will explain how we can measure test code coverage and what plugin
+
+14
+00:01:03,000 --> 00:01:04,000
+will use for that.
+
+15
+00:01:05,000 --> 00:01:07,000
+Sounds like we have a lot of things to do.
+
+16
+00:01:07,000 --> 00:01:08,000
+Let's start.
+
+17
+00:01:08,000 --> 00:01:12,000
+I really believe that it is better to learn this topic on examples.
+
+18
+00:01:12,000 --> 00:01:13,000
+So let me open Eclipse.
+
+19
+00:01:14,000 --> 00:01:16,000
+This is our test from the previous lesson.
+
+20
+00:01:17,000 --> 00:01:20,000
+In case you missed first lesson, please get back and watch it.
+
+21
+00:01:21,000 --> 00:01:27,000
+Meanwhile, will keep improving our tests here and assessing for visibility and for documentation.
+
+22
+00:01:27,000 --> 00:01:31,000
+Your test properly we can use display name annotation.
+
+23
+00:01:31,000 --> 00:01:32,000
+Let me show you this.
+
+24
+00:01:33,000 --> 00:01:37,000
+You can apply this annotation to the class and specify clear name.
+
+25
+00:01:38,000 --> 00:01:41,000
+Also, we can apply this notation for each specific test match.
+
+26
+00:01:41,000 --> 00:01:48,000
+You can use any characters and even emoji if you wish, that also display name generators.
+
+27
+00:01:48,000 --> 00:01:50,000
+You can use generators on the class level.
+
+28
+00:01:51,000 --> 00:01:55,000
+For example, I use generators that substitutes underscores with spaces.
+
+29
+00:01:55,000 --> 00:02:02,000
+As you can see, I use an annotation displaying the generation inside this annotation I use in a class
+
+30
+00:02:02,000 --> 00:02:10,000
+of display name generator that is called replace underscores this auto display name generator can be
+
+31
+00:02:10,000 --> 00:02:16,000
+helpful because on some project specific way of naming test methods can be used, namely sometimes in
+
+32
+00:02:16,000 --> 00:02:20,000
+tests with name methods, with underscore to increase visibility.
+
+33
+00:02:20,000 --> 00:02:23,000
+Let me run tests to show you the result.
+
+34
+00:02:24,000 --> 00:02:30,000
+Here you can see the display name of our test class is changed, and inside you can see the display
+
+35
+00:02:30,000 --> 00:02:30,000
+method.
+
+36
+00:02:30,000 --> 00:02:35,000
+The first test is different and under scores are removed for the second test.
+
+37
+00:02:36,000 --> 00:02:41,000
+Can you see now that readability is increased in comparison with other methods listed here?
+
+38
+00:02:42,000 --> 00:02:47,000
+Instead of the display name generator, you can use other generators that are available here.
+
+39
+00:02:47,000 --> 00:02:50,000
+Here is a list of other generators that you can use.
+
+40
+00:02:50,000 --> 00:02:51,000
+Hope this is clear.
+
+41
+00:02:52,000 --> 00:02:52,000
+Let's move on.
+
+42
+00:02:53,000 --> 00:03:00,000
+Let's talk about assertions in unit where you saw how we wrote these tests in previous lesson.
+
+43
+00:03:00,000 --> 00:03:04,000
+And you know that we have a lot of research and methods located in assertions class.
+
+44
+00:03:04,000 --> 00:03:09,000
+All methods are static and usually we do static in parts of ascensions class.
+
+45
+00:03:09,000 --> 00:03:12,000
+Let's look at assertions that we didn't talk about yet.
+
+46
+00:03:13,000 --> 00:03:16,000
+I put all new examples at the bottom of this file.
+
+47
+00:03:16,000 --> 00:03:22,000
+I will share with you link to the source code after the lesson so you could find these examples and
+
+48
+00:03:22,000 --> 00:03:23,000
+investigate them separately.
+
+49
+00:03:24,000 --> 00:03:30,000
+For example, you can group your assertions sometimes that is logical and more visible.
+
+50
+00:03:30,000 --> 00:03:36,000
+I believe you remember our first test when we verify transaction here is a similar test.
+
+51
+00:03:36,000 --> 00:03:42,000
+But in the last part I use a search all Masset to group my two assertions.
+
+52
+00:03:42,000 --> 00:03:49,000
+This massive takes head that you will see in case one of the assertions will fail and you pass verbal
+
+53
+00:03:49,000 --> 00:03:51,000
+Lancs argument of type executable.
+
+54
+00:03:52,000 --> 00:03:58,000
+Usually object of this type is described with the help of the expression and you can see that in lambda
+
+55
+00:03:58,000 --> 00:03:58,000
+function.
+
+56
+00:03:58,000 --> 00:04:03,000
+I execute my own assertions in case one of these will be failed.
+
+57
+00:04:03,000 --> 00:04:08,000
+In report you will see that group of assertions with this header is failed.
+
+58
+00:04:08,000 --> 00:04:10,000
+Hope this is clearer with this example.
+
+59
+00:04:11,000 --> 00:04:16,000
+In the next example, I am going to show you how you can write dependent assertions.
+
+60
+00:04:16,000 --> 00:04:18,000
+Hammerson is easy here.
+
+61
+00:04:18,000 --> 00:04:22,000
+We can use nested assertions qaisi example.
+
+62
+00:04:22,000 --> 00:04:31,000
+We test the same money transaction I write asserts all and inside I have Asatru this assertion will
+
+63
+00:04:31,000 --> 00:04:33,000
+check the transfer money returned.
+
+64
+00:04:33,000 --> 00:04:40,000
+True, that would mean the transaction was successful and only after that I will check that amount of
+
+65
+00:04:40,000 --> 00:04:47,000
+money exchanged for account one and the account to and in a all method will be executed only in case.
+
+66
+00:04:47,000 --> 00:04:52,000
+First assertion that the seller Asatru method will pass.
+
+67
+00:04:52,000 --> 00:04:53,000
+Does it make sense.
+
+68
+00:04:54,000 --> 00:04:54,000
+Great.
+
+69
+00:04:55,000 --> 00:04:55,000
+Let's continue.
+
+70
+00:04:56,000 --> 00:05:03,000
+The next assertion will help us to be sure the time spent on execution of our method does not exceed
+
+71
+00:05:03,000 --> 00:05:05,000
+specified by US amount of time.
+
+72
+00:05:05,000 --> 00:05:06,000
+This is needed in the case.
+
+73
+00:05:06,000 --> 00:05:13,000
+We want to be sure that, for example, some complex method with a lot of logic inside that it doesn't
+
+74
+00:05:13,000 --> 00:05:15,000
+take more than one second to execute.
+
+75
+00:05:15,000 --> 00:05:18,000
+In our particular case, I want to test transfer money.
+
+76
+00:05:18,000 --> 00:05:21,000
+MassArt does not take more than one second to execute.
+
+77
+00:05:22,000 --> 00:05:26,000
+I use a certain amount method and pass to arguments to it.
+
+78
+00:05:26,000 --> 00:05:29,000
+The first argument is a duration object.
+
+79
+00:05:29,000 --> 00:05:33,000
+In a separate lesson, we learn with the tools for time management in JDK.
+
+80
+00:05:33,000 --> 00:05:36,000
+Right now you can just use duration class.
+
+81
+00:05:36,000 --> 00:05:39,000
+Don't forget to make an impact from Java Time package.
+
+82
+00:05:39,000 --> 00:05:41,000
+In case you use Eclipse.
+
+83
+00:05:41,000 --> 00:05:45,000
+It will help you with other suggestion and will improve this class instead of you.
+
+84
+00:05:46,000 --> 00:05:53,000
+You can use static methods, for example, of seconds to get duration in seconds of minutes to get duration
+
+85
+00:05:53,000 --> 00:05:55,000
+in milliseconds and so on.
+
+86
+00:05:56,000 --> 00:06:03,000
+I use of seconds method and the second argument similar to our previous examples, I pass lambda function
+
+87
+00:06:03,000 --> 00:06:10,000
+and execute my method and sided test will pass in case this method execution took less than one second
+
+88
+00:06:10,000 --> 00:06:14,000
+and it will fail in case method execution took longer.
+
+89
+00:06:14,000 --> 00:06:21,000
+Talking about timeouts, it is also worth to mention that a certain mouth method returns the result.
+
+90
+00:06:21,000 --> 00:06:27,000
+For example, in this case a certain amount will return the result of my transfer money method.
+
+91
+00:06:28,000 --> 00:06:31,000
+That means that I am able to test time out of method.
+
+92
+00:06:31,000 --> 00:06:35,000
+The execution and the actual result I test.
+
+93
+00:06:35,000 --> 00:06:38,000
+The transaction was successful in a certain method.
+
+94
+00:06:39,000 --> 00:06:42,000
+Also, there is another way to check them out.
+
+95
+00:06:42,000 --> 00:06:49,000
+We can use annotation timeout right above the test method by default time use it and said the annotation
+
+96
+00:06:49,000 --> 00:06:51,000
+is seconds, but it is configurable.
+
+97
+00:06:51,000 --> 00:06:57,000
+And you can see in this command line how you can configure time unit for this annotation.
+
+98
+00:06:57,000 --> 00:07:00,000
+Just your second argument as time unit.
+
+99
+00:07:00,000 --> 00:07:01,000
+Does it make sense?
+
+100
+00:07:02,000 --> 00:07:02,000
+Great.
+
+101
+00:07:03,000 --> 00:07:08,000
+You already learned a lot of tools that will help you in daily activities while writing unit tests.
+
+102
+00:07:09,000 --> 00:07:15,000
+Now I want to tell you about very interesting to injure Unit I talking about mechanism of assumptions.
+
+103
+00:07:15,000 --> 00:07:22,000
+Imagine that you wrote a unit test, but you want to vividly specify what is a valid input for this
+
+104
+00:07:22,000 --> 00:07:23,000
+test in case in.
+
+105
+00:07:24,000 --> 00:07:26,000
+This message was invalid with this death.
+
+106
+00:07:27,000 --> 00:07:31,000
+Don't worry, I will show you an example now and everything will become clear.
+
+107
+00:07:32,000 --> 00:07:38,000
+Imagine that I wrote a test that should be run only on local development environment and another test
+
+108
+00:07:38,000 --> 00:07:41,000
+that should be run on quality assurance environment.
+
+109
+00:07:42,000 --> 00:07:44,000
+These environments use different configurations.
+
+110
+00:07:45,000 --> 00:07:48,000
+While this is not a good practice, it is very common sense.
+
+111
+00:07:49,000 --> 00:07:55,000
+And you want that one specific test would run only on local computers and another test would be run
+
+112
+00:07:55,000 --> 00:07:56,000
+on a server.
+
+113
+00:07:56,000 --> 00:07:57,000
+How to do that?
+
+114
+00:07:57,000 --> 00:08:01,000
+We can assume some statement before running tests.
+
+115
+00:08:01,000 --> 00:08:05,000
+For example, this test will be executed only on my laptop.
+
+116
+00:08:06,000 --> 00:08:12,000
+I write assume true at the beginning and pass statements that should return true or false in history
+
+117
+00:08:12,000 --> 00:08:14,000
+will be returned to you.
+
+118
+00:08:14,000 --> 00:08:18,000
+It will proceed with the test execution and his statement will be false.
+
+119
+00:08:19,000 --> 00:08:23,000
+You will just keep this test and will print the string message in the report.
+
+120
+00:08:24,000 --> 00:08:28,000
+I said environment variable on my computer that is called is an Ripperton laptop.
+
+121
+00:08:29,000 --> 00:08:30,000
+It has true value.
+
+122
+00:08:30,000 --> 00:08:36,000
+In case I will change the statement a bit, I will get false and this test will be skipped.
+
+123
+00:08:36,000 --> 00:08:42,000
+Let me run now all tests to show you how this look like and hand test reports.
+
+124
+00:08:42,000 --> 00:08:47,000
+You can see how much tests were run and the number of tests in parentheses.
+
+125
+00:08:48,000 --> 00:08:51,000
+Let's expand the report and check which test was kept.
+
+126
+00:08:52,000 --> 00:08:58,000
+And here you can see the test on Batalha Workstation is escaped because assumption is failed.
+
+127
+00:08:59,000 --> 00:09:06,000
+So what is the difference between assertion and assumption, you assert is used to test scenarios for
+
+128
+00:09:06,000 --> 00:09:12,000
+our test methods, whereas ASSUME is used to validate favorable conditions for our tests.
+
+129
+00:09:13,000 --> 00:09:17,000
+Here's how you can configure was a test should be executed or skipped.
+
+130
+00:09:18,000 --> 00:09:21,000
+Now I want to show you another key feature of the unit.
+
+131
+00:09:21,000 --> 00:09:23,000
+I am talking about parametrized test.
+
+132
+00:09:24,000 --> 00:09:29,000
+Imagine that you have one test and you want to run it multiple times with different values.
+
+133
+00:09:29,000 --> 00:09:31,000
+You don't have to write different tests.
+
+134
+00:09:31,000 --> 00:09:35,000
+You can just specify that this test will have different inputs.
+
+135
+00:09:35,000 --> 00:09:36,000
+How to do this?
+
+136
+00:09:36,000 --> 00:09:37,000
+Let me show you.
+
+137
+00:09:38,000 --> 00:09:44,000
+First of all, we have to write parametrized, test annotation instead of our regular test annotation.
+
+138
+00:09:44,000 --> 00:09:50,000
+The second thing we have to do is to write value source annotation in parentheses.
+
+139
+00:09:50,000 --> 00:09:57,000
+Next to this annotation, we can specify arrays of different types, namely moulins, bytes, chars
+
+140
+00:09:57,000 --> 00:10:02,000
+classes, double slots in long shorts and strings.
+
+141
+00:10:02,000 --> 00:10:07,000
+Even in case you would forget this, you just use auto suggestion to work.
+
+142
+00:10:07,000 --> 00:10:07,000
+I do.
+
+143
+00:10:08,000 --> 00:10:11,000
+You can press control and space simultaneously to see.
+
+144
+00:10:11,000 --> 00:10:19,000
+Hence, in my particular example, I need INTs and next to end I specify array of in braces.
+
+145
+00:10:19,000 --> 00:10:24,000
+The third thing we have to do is to declare method parameter in our test.
+
+146
+00:10:24,000 --> 00:10:29,000
+This time should be compatible with the one we specified in the values source annotation.
+
+147
+00:10:30,000 --> 00:10:38,000
+I declare parameter of type end and now this test will be executed four times y four because I have
+
+148
+00:10:38,000 --> 00:10:40,000
+four inputs to be specific.
+
+149
+00:10:40,000 --> 00:10:47,000
+In this case, test will be executed four times, but the fourth attempt will be skipped because I have
+
+150
+00:10:47,000 --> 00:10:51,000
+assumption here that money amounts should be strictly more than zero.
+
+151
+00:10:51,000 --> 00:10:54,000
+Let me run this test and show you to report.
+
+152
+00:10:55,000 --> 00:11:00,000
+And here you must see that our parametrized test was executed four times with different arguments.
+
+153
+00:11:01,000 --> 00:11:07,000
+And you also can see that force execution of test with minus Tanavoli was skipped because of assumption
+
+154
+00:11:07,000 --> 00:11:08,000
+failed.
+
+155
+00:11:08,000 --> 00:11:09,000
+Is that clear?
+
+156
+00:11:10,000 --> 00:11:14,000
+To parameterize your test, you can use such annotations.
+
+157
+00:11:14,000 --> 00:11:16,000
+S no source your source?
+
+158
+00:11:17,000 --> 00:11:18,000
+No an empty source.
+
+159
+00:11:19,000 --> 00:11:22,000
+You can use these annotations with parametrized tests.
+
+160
+00:11:22,000 --> 00:11:25,000
+I believe that all these annotations are self-described.
+
+161
+00:11:26,000 --> 00:11:32,000
+No source will just add no value to array of input values and your source will pass empty argument for
+
+162
+00:11:32,000 --> 00:11:41,000
+parameters of the following types like Screenplay's said map, primitive arrays into HRB, etc..
+
+163
+00:11:41,000 --> 00:11:43,000
+Object arrays and integer arrays.
+
+164
+00:11:43,000 --> 00:11:48,000
+Whatever new and empty source is a combination of first two annotations.
+
+165
+00:11:49,000 --> 00:11:55,000
+In case you would run this test, you would see that it will be executed two times with no an empty
+
+166
+00:11:55,000 --> 00:11:56,000
+string argument.
+
+167
+00:11:56,000 --> 00:12:01,000
+And as a annotation for test, parameterization is a method source annotation.
+
+168
+00:12:01,000 --> 00:12:04,000
+You can mark any static method with this annotation.
+
+169
+00:12:04,000 --> 00:12:10,000
+This is so-called factory method that generates stream of arguments that will be submitted to the parametrized
+
+170
+00:12:10,000 --> 00:12:11,000
+method.
+
+171
+00:12:11,000 --> 00:12:13,000
+Let me show you this on the example.
+
+172
+00:12:13,000 --> 00:12:19,000
+I have parametrized test that is marked with method source annotation and name of the method that should
+
+173
+00:12:19,000 --> 00:12:23,000
+be used to generate test inputs and use my static.
+
+174
+00:12:23,000 --> 00:12:29,000
+Method that is used to generate inputs, it returns stream type, but actually it can return any type
+
+175
+00:12:29,000 --> 00:12:31,000
+that can be converted to a string.
+
+176
+00:12:32,000 --> 00:12:37,000
+For example, collection iterator, a terrible extreme double stream and long stream.
+
+177
+00:12:37,000 --> 00:12:44,000
+And when I run test method source, it is executed three times because it generates three with three
+
+178
+00:12:44,000 --> 00:12:44,000
+values.
+
+179
+00:12:44,000 --> 00:12:45,000
+Does it make sense?
+
+180
+00:12:46,000 --> 00:12:52,000
+There's also a possibility to specify multiple data inputs by using Azziz resource annotation.
+
+181
+00:12:52,000 --> 00:12:56,000
+We use comma separated values to parse all arguments.
+
+182
+00:12:56,000 --> 00:12:57,000
+It is pretty intuitive.
+
+183
+00:12:57,000 --> 00:12:59,000
+If you would look at this example.
+
+184
+00:12:59,000 --> 00:13:02,000
+To be honest, I don't use parametrized test.
+
+185
+00:13:03,000 --> 00:13:05,000
+Why do you remember that?
+
+186
+00:13:05,000 --> 00:13:08,000
+In previous lesson I explained you what equivalence class is?
+
+187
+00:13:09,000 --> 00:13:10,000
+That is the answer.
+
+188
+00:13:10,000 --> 00:13:17,000
+I don't need parametrized test because I write test for only one value for a specific equivalence class
+
+189
+00:13:17,000 --> 00:13:19,000
+that is also works just fine.
+
+190
+00:13:19,000 --> 00:13:22,000
+But you can use parametrized test if you wish.
+
+191
+00:13:22,000 --> 00:13:25,000
+At least you should be aware about this feature.
+
+192
+00:13:25,000 --> 00:13:32,000
+Now imagine that you found some defect and this test is failing and take into account that usually development
+
+193
+00:13:32,000 --> 00:13:33,000
+is performed in teams.
+
+194
+00:13:33,000 --> 00:13:37,000
+This test also failed on other computers to not book anyone else.
+
+195
+00:13:37,000 --> 00:13:41,000
+You just disable some unit test until it will be fixed.
+
+196
+00:13:41,000 --> 00:13:44,000
+Hope you can easily imagine this case now.
+
+197
+00:13:44,000 --> 00:13:48,000
+How to disable test into a unit into unit four.
+
+198
+00:13:48,000 --> 00:13:51,000
+We used to ignore annotation in unit five.
+
+199
+00:13:51,000 --> 00:13:53,000
+We use disabled annotation.
+
+200
+00:13:53,000 --> 00:13:57,000
+You can just keep this annotation if you wish, or you can add description.
+
+201
+00:13:57,000 --> 00:14:04,000
+Why exactly this test is disabled and when you run all tests, this one just won't be executed.
+
+202
+00:14:05,000 --> 00:14:06,000
+Great.
+
+203
+00:14:06,000 --> 00:14:08,000
+We have one more quick topic to cover.
+
+204
+00:14:08,000 --> 00:14:10,000
+That is test code coverage.
+
+205
+00:14:10,000 --> 00:14:11,000
+What is this?
+
+206
+00:14:11,000 --> 00:14:17,000
+This is a Madgwick some specific values that shows in percentage how much lines of your code was covered
+
+207
+00:14:17,000 --> 00:14:18,000
+with tests.
+
+208
+00:14:18,000 --> 00:14:21,000
+This is important for us because of your reasons.
+
+209
+00:14:22,000 --> 00:14:27,000
+We want to be sure that all codes that we wrote is covered with tests in case we have codes that is
+
+210
+00:14:27,000 --> 00:14:29,000
+not covered with tests.
+
+211
+00:14:29,000 --> 00:14:31,000
+That means we don't need this code at all.
+
+212
+00:14:32,000 --> 00:14:38,000
+Sometimes we want to provide the metrics for important purposes that our job was done with expected
+
+213
+00:14:38,000 --> 00:14:39,000
+quality level.
+
+214
+00:14:39,000 --> 00:14:44,000
+And sometimes you might be asked to keep the percentage of test code coverage on the specific level.
+
+215
+00:14:45,000 --> 00:14:51,000
+How this code coverage works, that's code coverage shows how much lines and blocks were invoked from
+
+216
+00:14:51,000 --> 00:14:52,000
+your tests.
+
+217
+00:14:52,000 --> 00:14:59,000
+In other words, specific plug and measure how much lines of code were executed when your test is run.
+
+218
+00:15:00,000 --> 00:15:01,000
+That's why that's got coverage.
+
+219
+00:15:01,000 --> 00:15:06,000
+Not necessarily means that your test really verifies things and logic.
+
+220
+00:15:06,000 --> 00:15:13,000
+You can just invoke some method from your test or simulate any other conditions to execute other parts
+
+221
+00:15:13,000 --> 00:15:14,000
+of, if else, statement.
+
+222
+00:15:14,000 --> 00:15:15,000
+And that's it.
+
+223
+00:15:16,000 --> 00:15:19,000
+Such metric as test coverage will be increased.
+
+224
+00:15:19,000 --> 00:15:26,000
+To help you understand how tasket coverage works, let me show you this on example from the code editor
+
+225
+00:15:26,000 --> 00:15:27,000
+Error Mouse.
+
+226
+00:15:27,000 --> 00:15:30,000
+Right click coverage as a test.
+
+227
+00:15:30,000 --> 00:15:37,000
+In case you don't have such option, make sure that you have a grammar plugin installed and clips for
+
+228
+00:15:37,000 --> 00:15:42,000
+Java developers is distributed with this plugin installed by default.
+
+229
+00:15:42,000 --> 00:15:45,000
+Button Kizzire clips version doesn't have such plugin.
+
+230
+00:15:46,000 --> 00:15:47,000
+You can install it manually.
+
+231
+00:15:48,000 --> 00:15:49,000
+Just click help then.
+
+232
+00:15:49,000 --> 00:15:57,000
+Select Eclipse Market Place after Eclipse Marketplace is loaded use search bar to find a clammer.
+
+233
+00:15:57,000 --> 00:16:01,000
+A Clela is a plugin that can calculate Trescott coverage.
+
+234
+00:16:01,000 --> 00:16:06,000
+Inside the clips it is shown that it is already installed for me.
+
+235
+00:16:06,000 --> 00:16:11,000
+I click cancel and now I want to execute my test and check descant coverage.
+
+236
+00:16:12,000 --> 00:16:16,000
+After test is executed, I can find Trescott coverage report.
+
+237
+00:16:17,000 --> 00:16:22,000
+It says that this test covers only such specific parts of all lines in my project.
+
+238
+00:16:22,000 --> 00:16:25,000
+Let me expand folders from this report.
+
+239
+00:16:25,000 --> 00:16:28,000
+You can source all items here by coverage rate.
+
+240
+00:16:29,000 --> 00:16:35,000
+As you can see, my unit test covered on one hundred percent, my money transaction service and account
+
+241
+00:16:35,000 --> 00:16:35,000
+class.
+
+242
+00:16:36,000 --> 00:16:37,000
+That is awesome.
+
+243
+00:16:37,000 --> 00:16:43,000
+You can open each specific class now to see lines and green that are covered with your test.
+
+244
+00:16:43,000 --> 00:16:49,000
+Let me open my transaction service and you can see that all lines and blocks are covered with tests.
+
+245
+00:16:50,000 --> 00:16:51,000
+How to reset this?
+
+246
+00:16:52,000 --> 00:16:58,000
+Just find this cross sign in coverage report to reset all reports and color selection in your source
+
+247
+00:16:58,000 --> 00:16:58,000
+code.
+
+248
+00:16:59,000 --> 00:17:00,000
+What are the other statuses?
+
+249
+00:17:00,000 --> 00:17:06,000
+Could be you'll find your lines in red in case they were not covered by your test and you will find
+
+250
+00:17:06,000 --> 00:17:10,000
+yellow lines in case not all branches of execution are covered with tests.
+
+251
+00:17:11,000 --> 00:17:12,000
+Then we use these cases.
+
+252
+00:17:12,000 --> 00:17:13,000
+I created separate class.
+
+253
+00:17:14,000 --> 00:17:18,000
+It is called Trescott Coverage Damos and it is placed into unit folder.
+
+254
+00:17:19,000 --> 00:17:22,000
+It is really simple class created only for the sake of the example.
+
+255
+00:17:23,000 --> 00:17:30,000
+The matsutake swink argument it has, if else block first if statement contains expressions, that includes
+
+256
+00:17:30,000 --> 00:17:31,000
+or operator.
+
+257
+00:17:31,000 --> 00:17:38,000
+Let me show you the test now I have one single test and WOAK test code coverage method and personal
+
+258
+00:17:38,000 --> 00:17:39,000
+values there.
+
+259
+00:17:40,000 --> 00:17:45,000
+Now let me check this code coverage and run my tests when tests are executed.
+
+260
+00:17:45,000 --> 00:17:47,000
+Let me open the source code of our class.
+
+261
+00:17:48,000 --> 00:17:55,000
+You can see that each statement is yellow y because not all branches of execution are covered with tests.
+
+262
+00:17:56,000 --> 00:18:02,000
+We have two possible options here in case my strong argument is now, I will print this test to council.
+
+263
+00:18:03,000 --> 00:18:09,000
+And the second branch of execution is in case the string argument is not now, but it is empty string
+
+264
+00:18:09,000 --> 00:18:09,000
+object.
+
+265
+00:18:10,000 --> 00:18:13,000
+So that means I have to write one more test.
+
+266
+00:18:13,000 --> 00:18:18,000
+Westwick argument won't be now is red line in in block.
+
+267
+00:18:18,000 --> 00:18:21,000
+That is because it is not covered with test.
+
+268
+00:18:21,000 --> 00:18:26,000
+So you can see that my unit is covered with tests on sixty two and a half percentages.
+
+269
+00:18:27,000 --> 00:18:30,000
+But notice I even didn't test anything.
+
+270
+00:18:30,000 --> 00:18:37,000
+There is no assertion at all in my unit test, but I already increased Ascott coverage metric set as
+
+271
+00:18:37,000 --> 00:18:41,000
+the trigger that you should know about this cost coverage calculation to never use it.
+
+272
+00:18:42,000 --> 00:18:43,000
+We learned a lot today.
+
+273
+00:18:43,000 --> 00:18:46,000
+Let's recap what we have learned today.
+
+274
+00:18:47,000 --> 00:18:48,000
+We learned new annotations.
+
+275
+00:18:49,000 --> 00:18:55,000
+You also learned how to group assertions and how to build dependency between assertions and real examples.
+
+276
+00:18:55,000 --> 00:19:00,000
+You saw how to create unique tests that can be failed because of time out.
+
+277
+00:19:00,000 --> 00:19:03,000
+We learned how to use assumptions in the unit.
+
+278
+00:19:03,000 --> 00:19:10,000
+I explained you different ways to parameterize your test methods to repeat test with different inputs.
+
+279
+00:19:10,000 --> 00:19:14,000
+And at the end of the lesson we learned how to check Descant coverage.
+
+280
+00:19:14,000 --> 00:19:16,000
+Hope you enjoyed the lesson.
+
+281
+00:19:16,000 --> 00:19:18,000
+Thanks a lot for your attention.
+
+282
+00:19:18,000 --> 00:19:20,000
+See you in the next lesson.
+

34 - Unit Testing & JUnit 5/003 Source-code-of-test-1.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/test/com/itbulls/learnit/javacore/junit5/MoneyTransactionServiceTest2.java

34 - Unit Testing & JUnit 5/003 Source-code-of-test-2.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/test/com/itbulls/learnit/javacore/junit5/TestCodeCoverageDemoTest.java

34 - Unit Testing & JUnit 5/004 JUnit 5 API (Advanced p. 2) & Hamcrest Library_en.srt

@@ -0,0 +1,1124 @@
+1
+00:00:05,000 --> 00:00:06,000
+Hello, Jim.
+
+2
+00:00:06,000 --> 00:00:12,000
+In this lesson, we keep learning Janet API and advanced features, we'll start our lesson from learning
+
+3
+00:00:12,000 --> 00:00:16,000
+what suit is and how to create our own tasseled.
+
+4
+00:00:16,000 --> 00:00:20,000
+After that, I will explain to you what tagine is and how to take your tests.
+
+5
+00:00:21,000 --> 00:00:22,000
+During the lesson.
+
+6
+00:00:22,000 --> 00:00:26,000
+I'll show you a lot of examples that will help you to understand this topic better.
+
+7
+00:00:26,000 --> 00:00:30,000
+You will learn how to configure order of tests execution.
+
+8
+00:00:31,000 --> 00:00:33,000
+Besides that, I am going to show you a really cool feature.
+
+9
+00:00:34,000 --> 00:00:36,000
+It is conditional test execution.
+
+10
+00:00:36,000 --> 00:00:42,000
+You are going to learn how to set specific conditions to enable or disable your test programmatically.
+
+11
+00:00:43,000 --> 00:00:48,000
+Also, I will explain you how to create repeat a test that will be executed specified number of times.
+
+12
+00:00:48,000 --> 00:00:54,000
+I will explain you how temporary directory extension works and why we might need it.
+
+13
+00:00:54,000 --> 00:01:00,000
+I believe you already know how to use the unit assertions, but today I will also show you how to use
+
+14
+00:01:00,000 --> 00:01:03,000
+Honeycrisp Library to increase readability of your tests.
+
+15
+00:01:03,000 --> 00:01:08,000
+And at the end of the lesson, we are going to use the most common and typical mistakes.
+
+16
+00:01:08,000 --> 00:01:12,000
+Hopefully review and mistakes will help you to not repeat those.
+
+17
+00:01:12,000 --> 00:01:17,000
+I believe that the best way to learn this topic is to learn API with examples.
+
+18
+00:01:17,000 --> 00:01:19,000
+So let me open the clips.
+
+19
+00:01:19,000 --> 00:01:25,000
+Imagines a case that you wrote specifics of unit tests that are related to specific feature.
+
+20
+00:01:25,000 --> 00:01:31,000
+For example, all units are related to registration feature and while working on this feature, you
+
+21
+00:01:31,000 --> 00:01:34,000
+don't want to run all possible unit tests.
+
+22
+00:01:34,000 --> 00:01:39,000
+You want to run only those tests that are related to registration feature.
+
+23
+00:01:39,000 --> 00:01:44,000
+There are so-called test kits to help you to run group of tests with one click.
+
+24
+00:01:44,000 --> 00:01:46,000
+Let me show you how to create test.
+
+25
+00:01:47,000 --> 00:01:50,000
+The first thing you have to do is to specific run class.
+
+26
+00:01:51,000 --> 00:01:52,000
+What is Irana?
+
+27
+00:01:52,000 --> 00:01:56,000
+This is a class that is responsible for running unit tests.
+
+28
+00:01:56,000 --> 00:02:01,000
+There is a default unit run when we don't specify any specific granite class.
+
+29
+00:02:01,000 --> 00:02:07,000
+In this particular case, we have to specify and also run a class that is called the unit platform.
+
+30
+00:02:08,000 --> 00:02:14,000
+This class will check all configurations related with running group of tests, our tests.
+
+31
+00:02:15,000 --> 00:02:20,000
+The next thing we have to do is to add one of the notations that will help us to run group of tests.
+
+32
+00:02:21,000 --> 00:02:24,000
+It could be select packages, annotation from its name.
+
+33
+00:02:24,000 --> 00:02:26,000
+I believe that is clear.
+
+34
+00:02:26,000 --> 00:02:29,000
+What we have to pass to this annotation here.
+
+35
+00:02:29,000 --> 00:02:32,000
+I specify a package with unit test that I want to run.
+
+36
+00:02:32,000 --> 00:02:34,000
+Be careful.
+
+37
+00:02:34,000 --> 00:02:40,000
+This notation by default runs on the test that there is a machine with test O ended up with test or
+
+38
+00:02:40,000 --> 00:02:41,000
+test.
+
+39
+00:02:41,000 --> 00:02:47,000
+That's why in case you have some custom name for unit class, it will be not included in the test.
+
+40
+00:02:48,000 --> 00:02:52,000
+A little bit later, I will show you how to add any specific class by name.
+
+41
+00:02:52,000 --> 00:02:55,000
+You can specify multiple packages if you wish.
+
+42
+00:02:55,000 --> 00:03:00,000
+Just pass array of strings to annotation from the syntax standpoint.
+
+43
+00:03:00,000 --> 00:03:03,000
+Just wrap your strings and curly braces like I did here.
+
+44
+00:03:04,000 --> 00:03:05,000
+My default.
+
+45
+00:03:05,000 --> 00:03:10,000
+This notation tells to run tests in this package and all of its packages.
+
+46
+00:03:10,000 --> 00:03:15,000
+But what if I don't want to run all tests and I want to exclude test from specific package?
+
+47
+00:03:16,000 --> 00:03:22,000
+For example, I can specify here that I want to run all tests that exist in my project, excluding tests
+
+48
+00:03:22,000 --> 00:03:24,000
+from the unit package.
+
+49
+00:03:24,000 --> 00:03:31,000
+To do this, I have to use exclude packages annotation in case you want to include specific package
+
+50
+00:03:31,000 --> 00:03:37,000
+you can use include packages, annotation, hope that these annotations are self describing and you
+
+51
+00:03:37,000 --> 00:03:38,000
+can understand these easily.
+
+52
+00:03:39,000 --> 00:03:45,000
+Also, during the development of your tests, you can mark specific tasks with tasks a little bit later
+
+53
+00:03:45,000 --> 00:03:47,000
+in this lesson, I'll show you how to do this.
+
+54
+00:03:48,000 --> 00:03:54,000
+But imagine that there are some specifics in environmental configurations of each server and special
+
+55
+00:03:54,000 --> 00:03:59,000
+set of test should be run on development, environment and special set of tests should be executed on
+
+56
+00:03:59,000 --> 00:04:00,000
+production environment.
+
+57
+00:04:01,000 --> 00:04:07,000
+While these cases are relatively rare, it is still good to know that such a level of configuration
+
+58
+00:04:07,000 --> 00:04:08,000
+exists in the unit.
+
+59
+00:04:09,000 --> 00:04:14,000
+In case you want to run a specific class, you can use select classes, annotation and pass gloss to
+
+60
+00:04:14,000 --> 00:04:14,000
+it.
+
+61
+00:04:15,000 --> 00:04:21,000
+Similar to previous example, we can pass array of classes in case we want to execute multiple classes
+
+62
+00:04:21,000 --> 00:04:22,000
+in scope of this test.
+
+63
+00:04:23,000 --> 00:04:26,000
+It looks like that's we're regarding creation of tests.
+
+64
+00:04:26,000 --> 00:04:28,000
+Let's move on and see what else do we have.
+
+65
+00:04:29,000 --> 00:04:33,000
+You already saw how to include test that attacked with a specific attack.
+
+66
+00:04:34,000 --> 00:04:36,000
+Let's learn now how we can attack our tests.
+
+67
+00:04:37,000 --> 00:04:42,000
+We can use that connotation with classes and masses, the specific rules for tech names.
+
+68
+00:04:42,000 --> 00:04:44,000
+But all of them are pretty intuitive.
+
+69
+00:04:44,000 --> 00:04:51,000
+And in case you don't use any extraordinary name that it started with ampersand or exclamation point,
+
+70
+00:04:51,000 --> 00:04:51,000
+then are good.
+
+71
+00:04:52,000 --> 00:04:58,000
+The next thing that I want to discuss with you today is a test in order by default test, an order is
+
+72
+00:04:58,000 --> 00:05:01,000
+undermined and that is fine.
+
+73
+00:05:01,000 --> 00:05:04,000
+I believe you remember first principles and namely.
+
+74
+00:05:04,000 --> 00:05:08,000
+Is the latest principal, each test should be isolated from each other.
+
+75
+00:05:09,000 --> 00:05:11,000
+That's why it is not a big deal for us.
+
+76
+00:05:11,000 --> 00:05:13,000
+What is the order of test?
+
+77
+00:05:13,000 --> 00:05:19,000
+Execution is, but it provides us with opportunity to specify order of tests, execution.
+
+78
+00:05:20,000 --> 00:05:25,000
+In my opinion, this is extremely rare cases when you have to use this feature, but still you have
+
+79
+00:05:25,000 --> 00:05:28,000
+to know about it to specify order of tests.
+
+80
+00:05:28,000 --> 00:05:29,000
+We have to do a few things.
+
+81
+00:05:30,000 --> 00:05:37,000
+First thing we have to do is to add test methods, order in addition to the class and specify order
+
+82
+00:05:37,000 --> 00:05:42,000
+implementation that we want to use the different implementations that are available for us.
+
+83
+00:05:42,000 --> 00:05:50,000
+They are just plain name to search execution by display, name, method, name to sort of test execution
+
+84
+00:05:50,000 --> 00:05:57,000
+by test method names or the notation to search by order specified in annotation, random orders test
+
+85
+00:05:57,000 --> 00:06:01,000
+methods to the randomly and supports configuration of a custom seat.
+
+86
+00:06:02,000 --> 00:06:05,000
+In my opinion, using ornamentation is very convenient.
+
+87
+00:06:06,000 --> 00:06:07,000
+So let me show you how it works.
+
+88
+00:06:08,000 --> 00:06:12,000
+I specify all the annotation class in my test method order annotation.
+
+89
+00:06:13,000 --> 00:06:19,000
+After this, the only thing that I have to do is to add order annotation to each test method and specify
+
+90
+00:06:19,000 --> 00:06:21,000
+in the order of each.
+
+91
+00:06:21,000 --> 00:06:24,000
+So the test was order one will be executed.
+
+92
+00:06:24,000 --> 00:06:29,000
+First test was ordered to will be executed next and so on.
+
+93
+00:06:29,000 --> 00:06:33,000
+That is how simply we can configure order of execution for our test.
+
+94
+00:06:33,000 --> 00:06:39,000
+But remember, usually each test should not rely on the test or the execution.
+
+95
+00:06:40,000 --> 00:06:45,000
+The next thing I wanted to discuss with you is a conditional test execution gene.
+
+96
+00:06:45,000 --> 00:06:50,000
+It allows us to disable or enable test based on the specific conditions.
+
+97
+00:06:50,000 --> 00:06:55,000
+We are going to learn annotations that will help us to configure specific conditions.
+
+98
+00:06:55,000 --> 00:06:59,000
+Basically, we can group all these annotations in the following groups.
+
+99
+00:06:59,000 --> 00:07:06,000
+Operating system conditions, Java runtime environment conditions, system, property conditions, environment,
+
+100
+00:07:06,000 --> 00:07:09,000
+variable conditions, custom conditions.
+
+101
+00:07:10,000 --> 00:07:11,000
+Let's review all examples.
+
+102
+00:07:11,000 --> 00:07:14,000
+One by one operating system.
+
+103
+00:07:14,000 --> 00:07:20,000
+Conditions allows you to enable or disable test based on the operating system of environment where code
+
+104
+00:07:20,000 --> 00:07:21,000
+is executed.
+
+105
+00:07:21,000 --> 00:07:27,000
+Here you can see examples with enabling test on the operating system, on array of operating systems
+
+106
+00:07:27,000 --> 00:07:31,000
+and similar example with disabling test based on operating system.
+
+107
+00:07:32,000 --> 00:07:37,000
+Pay attention to their predefined constants for major operating systems in this class.
+
+108
+00:07:38,000 --> 00:07:43,000
+I will share the link to the source code of this test so that you could check all the statements that
+
+109
+00:07:43,000 --> 00:07:48,000
+they use to use these classes and annotations just in case it gives us a suggestion.
+
+110
+00:07:48,000 --> 00:07:50,000
+Tool should help you with this.
+
+111
+00:07:51,000 --> 00:07:57,000
+The next group of conditions will help you to enable or disable specific unit tests based on the particular
+
+112
+00:07:57,000 --> 00:07:58,000
+version of Jerry.
+
+113
+00:07:59,000 --> 00:08:05,000
+The specific annotations for NAINGGOLAN test for the specific Jerry enabling test for the arrays or
+
+114
+00:08:05,000 --> 00:08:11,000
+reversions enable for jury rank enabling for range by specifying easy, just minimum or just maximum
+
+115
+00:08:11,000 --> 00:08:13,000
+Jerry version.
+
+116
+00:08:13,000 --> 00:08:20,000
+You can do the similar things for the same tests and here you can find examples how this is clear.
+
+117
+00:08:20,000 --> 00:08:26,000
+Now let me show you annotations that will help you make conditions based on the system properties you
+
+118
+00:08:26,000 --> 00:08:28,000
+can use, enabled or disabled.
+
+119
+00:08:28,000 --> 00:08:35,000
+If property annotations to check if specific properties are equal to the value we pass here, the value
+
+120
+00:08:35,000 --> 00:08:36,000
+is applied.
+
+121
+00:08:36,000 --> 00:08:36,000
+We are much.
+
+122
+00:08:36,000 --> 00:08:39,000
+This attribute will be interpreted as a regular expression.
+
+123
+00:08:40,000 --> 00:08:42,000
+Actually, there is nothing more to add here.
+
+124
+00:08:43,000 --> 00:08:47,000
+Also, we can enable or disable test based on the environment variables.
+
+125
+00:08:47,000 --> 00:08:52,000
+Here you can see examples of these two annotations similar to previous example.
+
+126
+00:08:53,000 --> 00:08:59,000
+Value in matches attribute will be treated as a regular expression and the most interesting, in my
+
+127
+00:08:59,000 --> 00:09:01,000
+opinion, it is a custom condition.
+
+128
+00:09:02,000 --> 00:09:03,000
+Let me explain how it works.
+
+129
+00:09:04,000 --> 00:09:10,000
+We can use is a enable or disable if annotations and pastorate name or the method that we are going
+
+130
+00:09:10,000 --> 00:09:12,000
+to use to define the condition.
+
+131
+00:09:13,000 --> 00:09:19,000
+The method should return is a true or false, and based on this test will be is enabled or disabled.
+
+132
+00:09:20,000 --> 00:09:25,000
+This option gives you a lot of flexibility and definition of your own condition.
+
+133
+00:09:25,000 --> 00:09:27,000
+Does it make sense now?
+
+134
+00:09:27,000 --> 00:09:32,000
+You know all possible ways how to configure conditions to enable or disable your test.
+
+135
+00:09:32,000 --> 00:09:34,000
+Let's move on to the next topic.
+
+136
+00:09:35,000 --> 00:09:41,000
+Do it allows us to create repeat a test that will be repeated, specified number of times to create
+
+137
+00:09:41,000 --> 00:09:41,000
+such test.
+
+138
+00:09:41,000 --> 00:09:48,000
+Just use repeated test annotation, unspecified number of times to repeat it inside annotation.
+
+139
+00:09:48,000 --> 00:09:51,000
+Besides, no, we also can specify the name of the test.
+
+140
+00:09:52,000 --> 00:09:53,000
+Well, define a name.
+
+141
+00:09:53,000 --> 00:09:58,000
+We can use placeholders to display current repetition and total repetitions.
+
+142
+00:09:58,000 --> 00:09:59,000
+That's it.
+
+143
+00:10:00,000 --> 00:10:04,000
+This notation is useful when you want to make sure that even after multi.
+
+144
+00:10:04,000 --> 00:10:11,000
+Execution, tax returns, the same result, the next example I want to show you is about temporary director
+
+145
+00:10:11,000 --> 00:10:18,000
+in Unit four, there was so-called temporary folder rule that helped us to perform operations with file
+
+146
+00:10:18,000 --> 00:10:20,000
+only in scope of our union test.
+
+147
+00:10:20,000 --> 00:10:25,000
+In grade five, we have similar feature, but implemented in more intuitive way.
+
+148
+00:10:25,000 --> 00:10:29,000
+Imagine that your application stores some data to your file system.
+
+149
+00:10:30,000 --> 00:10:36,000
+Imagine that you want to store receipt of all purchases in the online store and you want to test the
+
+150
+00:10:36,000 --> 00:10:40,000
+content of this file instead of fighting the workarounds.
+
+151
+00:10:40,000 --> 00:10:44,000
+How to create files first and after all, test passed.
+
+152
+00:10:44,000 --> 00:10:50,000
+Remove these files and also be bothered about other questions like how to separate test and non test
+
+153
+00:10:50,000 --> 00:10:54,000
+files and so on to avoid answering these questions.
+
+154
+00:10:54,000 --> 00:10:56,000
+There is a temporary folder extension.
+
+155
+00:10:56,000 --> 00:10:58,000
+Let me show you how you can use it.
+
+156
+00:10:59,000 --> 00:11:07,000
+Basically, in any test method we can pass such argument as pass was annotation stampeder after that.
+
+157
+00:11:07,000 --> 00:11:13,000
+Inside the test we can resolve the pass and do this, pass everything we need.
+
+158
+00:11:13,000 --> 00:11:20,000
+For example, in this particular case I wrote some text to a file and after that verified the text and
+
+159
+00:11:20,000 --> 00:11:26,000
+file is the same as I expect after test execution's, this file will be removed.
+
+160
+00:11:26,000 --> 00:11:29,000
+So there is no impact on your local file system.
+
+161
+00:11:30,000 --> 00:11:33,000
+That's how easily you can use temporary directory extension.
+
+162
+00:11:33,000 --> 00:11:34,000
+Is it clear?
+
+163
+00:11:35,000 --> 00:11:35,000
+Awesome.
+
+164
+00:11:36,000 --> 00:11:39,000
+Also today we are going to have one more important topic.
+
+165
+00:11:40,000 --> 00:11:46,000
+I believe you already noticed that a lot of things in our Test MGE library is developed for the one
+
+166
+00:11:46,000 --> 00:11:50,000
+main increase readability of our test.
+
+167
+00:11:50,000 --> 00:11:57,000
+I mean, all these annotations like display neme extra long, massive names, naming mascots with underscore
+
+168
+00:11:57,000 --> 00:11:58,000
+and lots more.
+
+169
+00:11:59,000 --> 00:12:04,000
+And there is also a popular library the Java developers use often it is called Holmquist.
+
+170
+00:12:05,000 --> 00:12:11,000
+Even if you want to use it on a daily basis, you should be at least aware about it because it is very
+
+171
+00:12:11,000 --> 00:12:11,000
+popular.
+
+172
+00:12:12,000 --> 00:12:19,000
+So Ensures Holmquist is a library that allows us to achieve high reliability of our code by using custom
+
+173
+00:12:19,000 --> 00:12:22,000
+assertion methods and matchers as well known examples.
+
+174
+00:12:22,000 --> 00:12:28,000
+You understand what I am talking about and to start working with Holmquist, the first thing we have
+
+175
+00:12:28,000 --> 00:12:31,000
+to do is to add Humphris Library to our claspers.
+
+176
+00:12:32,000 --> 00:12:33,000
+How to do that?
+
+177
+00:12:33,000 --> 00:12:38,000
+I already show the imperiousness and how to add external jar's to our project.
+
+178
+00:12:38,000 --> 00:12:41,000
+But in this lesson we will do everything from the beginning.
+
+179
+00:12:41,000 --> 00:12:46,000
+So the first question, where to get Humphris Library in the Internet?
+
+180
+00:12:47,000 --> 00:12:49,000
+There really a lot of open repositories.
+
+181
+00:12:49,000 --> 00:12:52,000
+One of the biggest repository is Mavin repository.
+
+182
+00:12:53,000 --> 00:12:58,000
+We can type our Google search like this Holmquist Mavin Rappa.
+
+183
+00:12:58,000 --> 00:13:01,000
+Now let's open the first link from the list.
+
+184
+00:13:01,000 --> 00:13:07,000
+These are all libraries from Humphris, but today we need only one Holmquist.
+
+185
+00:13:07,000 --> 00:13:09,000
+Oh, here it is right on the top.
+
+186
+00:13:10,000 --> 00:13:15,000
+The library contains all modules that are needed to work efficiently with Congress.
+
+187
+00:13:15,000 --> 00:13:19,000
+On this page, we can choose a version of our Honkers Library.
+
+188
+00:13:19,000 --> 00:13:22,000
+I select the latest one on this page.
+
+189
+00:13:22,000 --> 00:13:28,000
+We can find instructions how to setup dependency on this library in projects was automated built tools.
+
+190
+00:13:29,000 --> 00:13:31,000
+But we have simple Java project.
+
+191
+00:13:31,000 --> 00:13:36,000
+Don't worry, we'll learn, automate, build tools later, but not in this lesson.
+
+192
+00:13:36,000 --> 00:13:41,000
+Right now we need to find how to download archive with Humphris classes.
+
+193
+00:13:41,000 --> 00:13:48,000
+And here I can download your file of Humphris Library Download File and get back to Eclipse.
+
+194
+00:13:48,000 --> 00:13:52,000
+Hearing the clips we have to adhere to Claspers Mouse right.
+
+195
+00:13:52,000 --> 00:13:58,000
+Click on our project, build POS, configure, build, pass here.
+
+196
+00:13:58,000 --> 00:14:00,000
+Make sure you can navigate at the library.
+
+197
+00:14:00,000 --> 00:14:02,000
+Step press on claspers.
+
+198
+00:14:03,000 --> 00:14:10,000
+Now click on Add External Jar's and here you can find Humphris libraries that we have just downloaded
+
+199
+00:14:10,000 --> 00:14:13,000
+and already have this library added to my claspers.
+
+200
+00:14:13,000 --> 00:14:15,000
+So I will just close this window.
+
+201
+00:14:15,000 --> 00:14:21,000
+When you added Humphris Library to a class pass, we can proceed with our examples, especially for
+
+202
+00:14:21,000 --> 00:14:22,000
+this lesson.
+
+203
+00:14:22,000 --> 00:14:25,000
+I created a separate file with compressed examples.
+
+204
+00:14:25,000 --> 00:14:28,000
+I will leave Lean to the source code attached to the lesson.
+
+205
+00:14:29,000 --> 00:14:31,000
+Let's write our first test with Congress.
+
+206
+00:14:31,000 --> 00:14:33,000
+We have simple test here.
+
+207
+00:14:33,000 --> 00:14:37,000
+Imagine we have two strings no matter how we received that.
+
+208
+00:14:37,000 --> 00:14:43,000
+In this example, I want to put all your focus on the syntax of Honkers instead of regular assertions
+
+209
+00:14:43,000 --> 00:14:45,000
+that you already used to into Unit five.
+
+210
+00:14:46,000 --> 00:14:49,000
+Your special message from Moccia, a search class.
+
+211
+00:14:49,000 --> 00:14:55,000
+This is called Assert that this is overloaded MassArt and one version of it takes three as the first
+
+212
+00:14:55,000 --> 00:14:56,000
+argument.
+
+213
+00:14:56,000 --> 00:15:01,000
+This string is used as an error message to be displayed in case test was failed.
+
+214
+00:15:01,000 --> 00:15:03,000
+Personally, I more often use an.
+
+215
+00:15:03,000 --> 00:15:09,000
+Another version of this massive that takes actual value as a first argument and the march as a second
+
+216
+00:15:09,000 --> 00:15:16,000
+argument, Humphris Marcia is a special type and can help you to identify the march according to the
+
+217
+00:15:16,000 --> 00:15:18,000
+requirements of the test.
+
+218
+00:15:18,000 --> 00:15:21,000
+Usually we use static methods that can return.
+
+219
+00:15:21,000 --> 00:15:27,000
+Matching object in this particular case are used equal to Masset from March 1st class.
+
+220
+00:15:28,000 --> 00:15:33,000
+This static method returns March as it will help us to check equality with the first argument.
+
+221
+00:15:33,000 --> 00:15:40,000
+And if you can notice that we received Stylize sentence, that is easy to read and to understand.
+
+222
+00:15:40,000 --> 00:15:42,000
+Let's look at another example.
+
+223
+00:15:42,000 --> 00:15:47,000
+Imagine that you have at least with values, and during the test you modified the state of the list.
+
+224
+00:15:48,000 --> 00:15:49,000
+Just imagine that.
+
+225
+00:15:49,000 --> 00:15:56,000
+And in a certain part of your test, we have to verify that list contains one of the expected values.
+
+226
+00:15:56,000 --> 00:16:06,000
+Here is a line written with Humphris assert that Liste has item any of equal to a equal to be equal
+
+227
+00:16:06,000 --> 00:16:11,000
+to see you like it is almost like a complete sentence.
+
+228
+00:16:11,000 --> 00:16:16,000
+And you can see that you can use marchers as an input argument to another marcher.
+
+229
+00:16:17,000 --> 00:16:19,000
+And right below we can see that same assertion.
+
+230
+00:16:19,000 --> 00:16:22,000
+But reason with do can't tell me what do you think?
+
+231
+00:16:23,000 --> 00:16:25,000
+What is more readable in your opinion?
+
+232
+00:16:26,000 --> 00:16:32,000
+Some of my students tell me that they still prefer giant assertions of a holmquist and that is completely
+
+233
+00:16:32,000 --> 00:16:33,000
+fine.
+
+234
+00:16:33,000 --> 00:16:36,000
+It is only a matter of coding style and nothing more.
+
+235
+00:16:36,000 --> 00:16:42,000
+I just want you to know about this library since it is popular, essentially.
+
+236
+00:16:42,000 --> 00:16:43,000
+That's it.
+
+237
+00:16:43,000 --> 00:16:49,000
+So the only thing that would be different from test to test is a march that you will choose to perform
+
+238
+00:16:49,000 --> 00:16:55,000
+the validation that different group of marchers I gathered all of them on one slide.
+
+239
+00:16:55,000 --> 00:16:56,000
+Let me show it to you.
+
+240
+00:16:57,000 --> 00:17:05,000
+There are such groups of marchers, core logical object, beanz collections, no text.
+
+241
+00:17:06,000 --> 00:17:09,000
+And on this slide, you can find a description for each of this march.
+
+242
+00:17:10,000 --> 00:17:15,000
+I believe that by name of each march you can understand what does do.
+
+243
+00:17:15,000 --> 00:17:19,000
+That's why I believe there is no need to go over each of these.
+
+244
+00:17:20,000 --> 00:17:24,000
+In the case that after reading of description for each march, you still have questions.
+
+245
+00:17:24,000 --> 00:17:28,000
+Do not hesitate to ask these questions in Q&A section.
+
+246
+00:17:29,000 --> 00:17:35,000
+And the last, but not least for today, I would love to use your typical mistakes that usually junior
+
+247
+00:17:35,000 --> 00:17:36,000
+developers do.
+
+248
+00:17:36,000 --> 00:17:37,000
+Based on my experience.
+
+249
+00:17:38,000 --> 00:17:41,000
+The first typical mistake is testing of Java API.
+
+250
+00:17:42,000 --> 00:17:48,000
+This mistake can have multiple and various forms, but the idea, as it stands behind its example,
+
+251
+00:17:48,000 --> 00:17:48,000
+is simple.
+
+252
+00:17:49,000 --> 00:17:51,000
+You don't have to test how Java works.
+
+253
+00:17:52,000 --> 00:17:58,000
+The second common mistake is to write a test that will never fail on the slide.
+
+254
+00:17:58,000 --> 00:18:04,000
+You can see very simple example to get the point in real life, the source code can be a bit more complicated,
+
+255
+00:18:04,000 --> 00:18:09,000
+but at the end of the day, specific scenario will always return.
+
+256
+00:18:09,000 --> 00:18:16,000
+True, if you remember in previous lesson I gave you one advice spend two more seconds to make sure
+
+257
+00:18:16,000 --> 00:18:18,000
+that you at least once in your life.
+
+258
+00:18:18,000 --> 00:18:24,000
+So each specific test in red status that would help you to avoid this mistake.
+
+259
+00:18:25,000 --> 00:18:28,000
+Huge test, that is our next mistake.
+
+260
+00:18:28,000 --> 00:18:31,000
+Don't try to test everything in one test.
+
+261
+00:18:31,000 --> 00:18:36,000
+Remember one assert per test or single concept for a test.
+
+262
+00:18:36,000 --> 00:18:42,000
+And also remember, do not hardcourt any values in court and avoid of using magic numbers.
+
+263
+00:18:43,000 --> 00:18:49,000
+We kind of discuss this topic and this advice already, but I want to make sure that you remember this.
+
+264
+00:18:49,000 --> 00:18:55,000
+It is better to use constants that are defined in your test class and that have clear name rather than
+
+265
+00:18:55,000 --> 00:18:56,000
+guessing.
+
+266
+00:18:56,000 --> 00:18:57,000
+What does this mean?
+
+267
+00:18:58,000 --> 00:19:01,000
+That was all made mistakes that I wanted to put your attention to.
+
+268
+00:19:02,000 --> 00:19:04,000
+Now let's recap what we have learned today.
+
+269
+00:19:05,000 --> 00:19:10,000
+We started our lesson was learned what test is and how to define the customer test.
+
+270
+00:19:10,000 --> 00:19:14,000
+But after that, we learned a little bit more about tagine.
+
+271
+00:19:14,000 --> 00:19:21,000
+In this lesson, I explained you how to configure order of test execution to make sure that tests are
+
+272
+00:19:21,000 --> 00:19:27,000
+running in predefined sequence uson examples how to create different kinds of conditional statements
+
+273
+00:19:27,000 --> 00:19:31,000
+that will allow you to enable or disable test upon specific condition.
+
+274
+00:19:32,000 --> 00:19:37,000
+Besides that, I also showed you a small example that explains how to create repeated tests.
+
+275
+00:19:37,000 --> 00:19:41,000
+Now you know how to use temporary Fulda Extension.
+
+276
+00:19:41,000 --> 00:19:43,000
+Well, testing input and output streams.
+
+277
+00:19:44,000 --> 00:19:51,000
+Also, I showed you how to use Hahm Christiania unit test and at the end of the lesson we learned typical
+
+278
+00:19:51,000 --> 00:19:52,000
+and most common mistakes.
+
+279
+00:19:53,000 --> 00:19:54,000
+That's it for today.
+
+280
+00:19:54,000 --> 00:19:56,000
+Thanks a lot for your attention.
+
+281
+00:19:56,000 --> 00:19:59,000
+Have a great day and see you in the next lesson.
+

34 - Unit Testing & JUnit 5/004 Source-code-of-Advanced-JUnit-Examples.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/test/com/itbulls/learnit/javacore/junit5/JUnitApiAdvancedExamples.java

34 - Unit Testing & JUnit 5/004 Source-code-of-Hamcrest-Library-Examples.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/tree/master/test/com/itbulls/learnit/javacore/hamcrest

34 - Unit Testing & JUnit 5/004 Source-code-of-Test-Suites.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/test/com/itbulls/learnit/javacore/junit5/TestSuiteExample.java

34 - Unit Testing & JUnit 5/external-links.txt

@@ -0,0 +1,24 @@
+
+002 JUnit-Documentation
+https://junit.org/junit5/docs/current/api/
+
+002 Source-code-of-MoneyTransactionService
+https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/junit5/MoneyTransactionService.java
+
+002 Source-code-of-MoneyTransactionServiceTest
+https://github.com/AndriiPiatakha/learnit_java_core/blob/master/test/com/itbulls/learnit/javacore/junit5/MoneyTransactionServiceTest.java
+
+003 Source-code-of-test-1
+https://github.com/AndriiPiatakha/learnit_java_core/blob/master/test/com/itbulls/learnit/javacore/junit5/MoneyTransactionServiceTest2.java
+
+003 Source-code-of-test-2
+https://github.com/AndriiPiatakha/learnit_java_core/blob/master/test/com/itbulls/learnit/javacore/junit5/TestCodeCoverageDemoTest.java
+
+004 Source-code-of-Test-Suites
+https://github.com/AndriiPiatakha/learnit_java_core/blob/master/test/com/itbulls/learnit/javacore/junit5/TestSuiteExample.java
+
+004 Source-code-of-Advanced-JUnit-Examples
+https://github.com/AndriiPiatakha/learnit_java_core/blob/master/test/com/itbulls/learnit/javacore/junit5/JUnitApiAdvancedExamples.java
+
+004 Source-code-of-Hamcrest-Library-Examples
+https://github.com/AndriiPiatakha/learnit_java_core/tree/master/test/com/itbulls/learnit/javacore/hamcrest

35 - Integration testing & Mockito/001 Integration Testing in Java_en.srt

@@ -0,0 +1,700 @@
+1
+00:00:06,000 --> 00:00:06,000
+Hello, Jim.
+
+2
+00:00:07,000 --> 00:00:11,000
+Today was that important section in this course we start learning how to perform integration testing
+
+3
+00:00:11,000 --> 00:00:12,000
+of our app.
+
+4
+00:00:12,000 --> 00:00:16,000
+We'll start from understanding what integration testing is.
+
+5
+00:00:16,000 --> 00:00:20,000
+To help you understand it better, we'll compare integration and unit testing.
+
+6
+00:00:20,000 --> 00:00:26,000
+I will explain what test numbers are and how they help us in testing will understand the advantages
+
+7
+00:00:26,000 --> 00:00:29,000
+of using test doubles in testing process.
+
+8
+00:00:29,000 --> 00:00:34,000
+After that, I'll share with you information about different types of integration testing.
+
+9
+00:00:34,000 --> 00:00:39,000
+And at the end of the lesson, we'll learn what frameworks are used for integration testing in Java.
+
+10
+00:00:40,000 --> 00:00:42,000
+Let's start at the beginning.
+
+11
+00:00:42,000 --> 00:00:45,000
+We have to understand what is integration tests.
+
+12
+00:00:45,000 --> 00:00:52,000
+In simple words, integration testing is a process where individual units are tested together to check
+
+13
+00:00:52,000 --> 00:00:55,000
+whether all the units interact with each other as expected.
+
+14
+00:00:56,000 --> 00:01:03,000
+So in the case of testing, we test only one specific unit in isolation, in integration testing.
+
+15
+00:01:03,000 --> 00:01:07,000
+We want to make sure that different units work together as expected.
+
+16
+00:01:08,000 --> 00:01:13,000
+For example, you want to be sure that when you use mail server to send an email, the message of template
+
+17
+00:01:13,000 --> 00:01:16,000
+engine that prepares content of our email are invoked.
+
+18
+00:01:17,000 --> 00:01:23,000
+Or for example, we want to be sure that in case there was an error in template engine, we didn't invoke
+
+19
+00:01:23,000 --> 00:01:27,000
+stand method of our mail server to send invalid message and so on.
+
+20
+00:01:28,000 --> 00:01:31,000
+Does it make sense during integration testing?
+
+21
+00:01:31,000 --> 00:01:38,000
+All our focus is put into verification of behavior that is happening not inside the one single object,
+
+22
+00:01:38,000 --> 00:01:40,000
+but between different objects.
+
+23
+00:01:41,000 --> 00:01:47,000
+The focus of the integration test and level is to expose the at the time of interaction between integrated
+
+24
+00:01:47,000 --> 00:01:54,000
+components or units to make sure that we are all here on the same page and that we are clearly understands
+
+25
+00:01:54,000 --> 00:01:57,000
+the difference between unit testing and integration testing.
+
+26
+00:01:57,000 --> 00:01:59,000
+Let's look at the next table here.
+
+27
+00:01:59,000 --> 00:02:04,000
+You can see the table where we separated attributes of unit and integration testing.
+
+28
+00:02:05,000 --> 00:02:12,000
+Let's go over each row one by one, and I will give my comments as we go in unit testing, test verifies
+
+29
+00:02:12,000 --> 00:02:20,000
+on the implementation of the code of one single unit, whereas in integration testing test puts main
+
+30
+00:02:20,000 --> 00:02:24,000
+attention on the interconnection behavior when they're used together.
+
+31
+00:02:25,000 --> 00:02:31,000
+The next thing we have to know is that a unit test uses only unit test frameworks like G Unit or testing
+
+32
+00:02:31,000 --> 00:02:32,000
+G and the Morgan framework.
+
+33
+00:02:33,000 --> 00:02:39,000
+Today we'll talk about what more and more can a framework is ensure during the unit testing.
+
+34
+00:02:39,000 --> 00:02:44,000
+Sometimes you need to use test doubles to replace real collaboration's of your unit with other units
+
+35
+00:02:45,000 --> 00:02:48,000
+or even simply to satisfy the requirements of COMPILER.
+
+36
+00:02:48,000 --> 00:02:52,000
+Don't worry, we'll also talk about test Dubbo's a little bit later today.
+
+37
+00:02:53,000 --> 00:02:58,000
+But when we talk about integration tests, we still can use Moken frameworks and test doubles for the
+
+38
+00:02:58,000 --> 00:03:00,000
+waste areas of the system.
+
+39
+00:03:00,000 --> 00:03:06,000
+For example, as I already mentioned, we need to test interaction and behavior between elements like
+
+40
+00:03:06,000 --> 00:03:12,000
+an example when mail server and Wolk's masses of template engine also an integration test.
+
+41
+00:03:12,000 --> 00:03:18,000
+And we can use real containers and real databases and use real components for integration testing.
+
+42
+00:03:18,000 --> 00:03:24,000
+For example, when one might project we had separate environment where automated acceptant testing was
+
+43
+00:03:24,000 --> 00:03:32,000
+executed, we had sort of integration test the test, our API, but still used marked fake components.
+
+44
+00:03:32,000 --> 00:03:39,000
+After running tests on eight environment, we executed our tests on so-called sealed environment system
+
+45
+00:03:39,000 --> 00:03:46,000
+integration testing test on that environment used real competence like real database, real payment
+
+46
+00:03:46,000 --> 00:03:49,000
+services, but just with the test data.
+
+47
+00:03:49,000 --> 00:03:55,000
+So as you can see, level of using fake objects and test doubles during the integration testing can
+
+48
+00:03:55,000 --> 00:04:01,000
+be different and will depend on your application and level of complexity of your system in general.
+
+49
+00:04:01,000 --> 00:04:07,000
+The next thing that is different in unit testing and integration testing is that failure in unit test
+
+50
+00:04:07,000 --> 00:04:09,000
+is always issue with the source code.
+
+51
+00:04:09,000 --> 00:04:11,000
+But failure and integration testing.
+
+52
+00:04:11,000 --> 00:04:17,000
+Besides, the issue with the source code also can mean changes in the environment and in other components.
+
+53
+00:04:18,000 --> 00:04:21,000
+Unit testing is a first layer of test in our testing pyramid.
+
+54
+00:04:22,000 --> 00:04:26,000
+If you don't miss any lessons before, I believe you remember what testing parameter is.
+
+55
+00:04:27,000 --> 00:04:32,000
+And this is important to understand that before starting the implementation of integration tests, we
+
+56
+00:04:32,000 --> 00:04:38,000
+have to be sure that all the years work properly in isolation and once all the components and modules
+
+57
+00:04:38,000 --> 00:04:44,000
+are working independently, then we need to check the data flow between the dependent modules that is
+
+58
+00:04:44,000 --> 00:04:45,000
+known as integration testing.
+
+59
+00:04:46,000 --> 00:04:52,000
+So I believe that is clear that integration testing is a second level of the software testing process
+
+60
+00:04:52,000 --> 00:04:54,000
+that comes after unit testing.
+
+61
+00:04:54,000 --> 00:05:00,000
+Now, I would like to talk about test Dubbo's during the unit test and integration test, and sometimes
+
+62
+00:05:00,000 --> 00:05:02,000
+we depend on the parts of our system.
+
+63
+00:05:03,000 --> 00:05:09,000
+We don't need at the moment or they are not ready to be tested now where it is impossible to reproduce
+
+64
+00:05:09,000 --> 00:05:13,000
+the state of some parts of the system on this particular environment and to write.
+
+65
+00:05:14,000 --> 00:05:20,000
+We have to use counter parts of those elements that would behave like release ready elements.
+
+66
+00:05:20,000 --> 00:05:26,000
+For example, you don't have available third party API that performs fraud verification of your user
+
+67
+00:05:26,000 --> 00:05:32,000
+during the purchase, but you have official documentation and you know how to imitate this API.
+
+68
+00:05:32,000 --> 00:05:36,000
+And now you can build something what behaves like real API.
+
+69
+00:05:37,000 --> 00:05:39,000
+But actually this isn't an actual API.
+
+70
+00:05:40,000 --> 00:05:43,000
+Such kind of units are called test double's.
+
+71
+00:05:43,000 --> 00:05:48,000
+Besides that, that's double simplified testing process and provider's responsibility to reduce the
+
+72
+00:05:48,000 --> 00:05:51,000
+complexity and facilitate testing.
+
+73
+00:05:51,000 --> 00:05:57,000
+That's doable is a generic term that is used to describe objects or procedures that will help us during
+
+74
+00:05:57,000 --> 00:05:59,000
+the testing was the case I described.
+
+75
+00:06:00,000 --> 00:06:06,000
+Test novel has to implement the same interface as real life object and meets the same requirements,
+
+76
+00:06:06,000 --> 00:06:08,000
+the different types of test.
+
+77
+00:06:08,000 --> 00:06:10,000
+Dubbo's let's look at them.
+
+78
+00:06:10,000 --> 00:06:13,000
+The first in our list is a dummy object.
+
+79
+00:06:13,000 --> 00:06:15,000
+What is a dummy object?
+
+80
+00:06:15,000 --> 00:06:20,000
+This is fake argument that is not really used and has no effect on the test.
+
+81
+00:06:20,000 --> 00:06:26,000
+Imagine that you have multiple parameters in the method and you just need to pass at least something
+
+82
+00:06:26,000 --> 00:06:31,000
+as an argument to execute this method, even in case you don't care about this argument at all.
+
+83
+00:06:31,000 --> 00:06:34,000
+The next type of test is a test.
+
+84
+00:06:34,000 --> 00:06:34,000
+Stop.
+
+85
+00:06:35,000 --> 00:06:38,000
+Stop is an object with hardcoded values to be returned.
+
+86
+00:06:38,000 --> 00:06:42,000
+It has no logic in sight and it is state oriented.
+
+87
+00:06:43,000 --> 00:06:48,000
+Steps are used to provide our test with input to imitate different life cases.
+
+88
+00:06:48,000 --> 00:06:55,000
+A fake object has implementation with shortcuts, so it is just a simplified version of the production
+
+89
+00:06:55,000 --> 00:06:55,000
+code.
+
+90
+00:06:56,000 --> 00:07:02,000
+It is usually used in integration testing, for example, to access and in-memory version of the production
+
+91
+00:07:02,000 --> 00:07:03,000
+database.
+
+92
+00:07:04,000 --> 00:07:11,000
+Mock a mock test double is a behavior oriented object used to assert InterAction's, it allows to use
+
+93
+00:07:11,000 --> 00:07:13,000
+methods to verify interactions.
+
+94
+00:07:13,000 --> 00:07:19,000
+For example, I can tell that some specific Masset was invoked with a specific list of parameters.
+
+95
+00:07:19,000 --> 00:07:23,000
+Also, I can calculate a number of times method was invoked.
+
+96
+00:07:23,000 --> 00:07:29,000
+We can also set expectations about Molk behavior before this code is executed.
+
+97
+00:07:29,000 --> 00:07:31,000
+And finally, spy.
+
+98
+00:07:31,000 --> 00:07:33,000
+A spy is similar to a mock.
+
+99
+00:07:33,000 --> 00:07:40,000
+It is also behavior oriented object used to assert interactions, but it is different from the mock
+
+100
+00:07:40,000 --> 00:07:43,000
+as delegates and monitor calls to real objects.
+
+101
+00:07:43,000 --> 00:07:50,000
+So you use real object with real methods and all interactions with spy are substituted with close to
+
+102
+00:07:50,000 --> 00:07:53,000
+real object unless some method was stopped.
+
+103
+00:07:54,000 --> 00:07:58,000
+So I want you to understand that Mock's are something totally different.
+
+104
+00:07:58,000 --> 00:08:06,000
+Until now, all our tests made assertions on a state marks a test double's that make assertions on behavior.
+
+105
+00:08:06,000 --> 00:08:10,000
+To understand the analogy, imagine that Moncks say something like this.
+
+106
+00:08:11,000 --> 00:08:18,000
+I expect that Masset one will be invoked with this string argument and if it is not there, I will throw
+
+107
+00:08:18,000 --> 00:08:19,000
+an error.
+
+108
+00:08:19,000 --> 00:08:25,000
+So Molk verifies behavior that the main goal of creating these kind of testable.
+
+109
+00:08:26,000 --> 00:08:32,000
+Let's now sum it up to understand why we have to use test Dubbo's during the testing and what advantages
+
+110
+00:08:32,000 --> 00:08:34,000
+we get from using that.
+
+111
+00:08:34,000 --> 00:08:38,000
+With the help of test double's, we isolate code that is under test.
+
+112
+00:08:38,000 --> 00:08:45,000
+We can be sure that we control all integration's and isolate specific parts of our system from each
+
+113
+00:08:45,000 --> 00:08:49,000
+other, substituting the real integrations with Test Dumbo's.
+
+114
+00:08:49,000 --> 00:08:56,000
+We can speed up test execution because integration test that uses real components for all kinds of integrations
+
+115
+00:08:56,000 --> 00:08:58,000
+can take hours to complete.
+
+116
+00:08:59,000 --> 00:09:05,000
+That's why very often a lot of parts in our integration test is substituted with test double's using
+
+117
+00:09:05,000 --> 00:09:06,000
+test Dubbo's.
+
+118
+00:09:06,000 --> 00:09:12,000
+We can stop specific behavior of our components and make execution of our test deterministic.
+
+119
+00:09:13,000 --> 00:09:18,000
+At the end of the day, we want to have control over execution of our test from the start to the end
+
+120
+00:09:19,000 --> 00:09:25,000
+test that helps us to reproduce special conditions and produce different states of our system to test
+
+121
+00:09:25,000 --> 00:09:27,000
+different use cases.
+
+122
+00:09:27,000 --> 00:09:28,000
+Does it make sense?
+
+123
+00:09:29,000 --> 00:09:33,000
+Before we move further, I want to explain the different types of integration testing.
+
+124
+00:09:34,000 --> 00:09:41,000
+Integration testing may be classified into two major groups ZAYA incremental integration testing and
+
+125
+00:09:41,000 --> 00:09:43,000
+non incremental integration testing.
+
+126
+00:09:44,000 --> 00:09:51,000
+In the incremental approach, modules are added in the ascending order one by one or according to need.
+
+127
+00:09:51,000 --> 00:09:57,000
+The selected modules must be logically related generally to unmuzzled.
+
+128
+00:09:57,000 --> 00:10:01,000
+Two modules are added and tested to determine the correctness of functions.
+
+129
+00:10:02,000 --> 00:10:08,000
+The process continues until the successful testing of all the modules they are top down and bottom up
+
+130
+00:10:08,000 --> 00:10:14,000
+approach is the top down testing strategy deals with the process in which high level modules are tested
+
+131
+00:10:14,000 --> 00:10:21,000
+with low level modules until the successful completion of testing of all the modules, major design
+
+132
+00:10:21,000 --> 00:10:27,000
+flaws can be detected and fixed early because critical modules tested first in this type of testing
+
+133
+00:10:27,000 --> 00:10:33,000
+will add the modules incrementally or one by one and check the data flow in the same order.
+
+134
+00:10:34,000 --> 00:10:39,000
+The bottom up testing strategy deals with the processes in which low level modules are tested with high
+
+135
+00:10:39,000 --> 00:10:44,000
+level modules and use the successful completion of testing of all the modules.
+
+136
+00:10:44,000 --> 00:10:49,000
+Top level critical modules are tested at last, so it may cause a defect.
+
+137
+00:10:49,000 --> 00:10:54,000
+Or we can say that we will be adding the modules from bottom to the top and checking the data flow in
+
+138
+00:10:54,000 --> 00:10:55,000
+the same order.
+
+139
+00:10:56,000 --> 00:10:59,000
+Let me explain more about non incremental integration testing.
+
+140
+00:11:00,000 --> 00:11:06,000
+We will go for this method when the data flow is very complex and when it is difficult to find who is
+
+141
+00:11:06,000 --> 00:11:13,000
+a parent and who is a child and in such case will create the data in any module and we will test interactions
+
+142
+00:11:13,000 --> 00:11:15,000
+with different modules without any specific logic.
+
+143
+00:11:16,000 --> 00:11:19,000
+That is why this method is also known as big bank Macit.
+
+144
+00:11:20,000 --> 00:11:25,000
+Now, when you know the theory of integration testing, let's learn what frameworks are used for integration
+
+145
+00:11:25,000 --> 00:11:26,000
+testing.
+
+146
+00:11:26,000 --> 00:11:31,000
+Probably the first framework that is used for integration testing is a unit.
+
+147
+00:11:31,000 --> 00:11:37,000
+Even despite developers use the unit primarily for unit testing, we still can use this library for
+
+148
+00:11:37,000 --> 00:11:38,000
+integration testing.
+
+149
+00:11:39,000 --> 00:11:43,000
+Also, probably one of the most popular libraries that we use during integration testing.
+
+150
+00:11:43,000 --> 00:11:45,000
+Is Makita an easy mark?
+
+151
+00:11:45,000 --> 00:11:52,000
+These libraries help us to create mock and spy objects YABE unit libraries that helps us to create test
+
+152
+00:11:52,000 --> 00:11:54,000
+for integration with database.
+
+153
+00:11:54,000 --> 00:12:00,000
+Mauck FCP Server Library provides us with different FCP Implementations FAQ and step.
+
+154
+00:12:00,000 --> 00:12:03,000
+It is just a few libraries in fact.
+
+155
+00:12:03,000 --> 00:12:09,000
+There are much more of them that will be used for defense specific cases, but the principle of working
+
+156
+00:12:09,000 --> 00:12:14,000
+with these libraries as a state, that means in case you would learn at least few libraries for integration
+
+157
+00:12:14,000 --> 00:12:20,000
+testing, it will be like piece of cake to learn other libraries by just reading documentation.
+
+158
+00:12:20,000 --> 00:12:25,000
+In this course, we are going to learn the most popular libraries for integration testing that you will
+
+159
+00:12:25,000 --> 00:12:32,000
+use most often, especially for all my students are prepared examples for each topic and I walk you
+
+160
+00:12:32,000 --> 00:12:33,000
+through all examples as we go.
+
+161
+00:12:34,000 --> 00:12:40,000
+I believe that we learned a lot for today and you already can understand and imagine what integration
+
+162
+00:12:40,000 --> 00:12:40,000
+testing is.
+
+163
+00:12:41,000 --> 00:12:46,000
+The only thing that we still need to do is to learn how to use frameworks that are listed in the lesson.
+
+164
+00:12:47,000 --> 00:12:49,000
+But we will do this in the next lessons.
+
+165
+00:12:49,000 --> 00:12:52,000
+Right now, let's recap what we have learned today.
+
+166
+00:12:53,000 --> 00:12:56,000
+In this lesson, we learned what integration testing is.
+
+167
+00:12:56,000 --> 00:13:01,000
+We made a comparison of unit and integration testing to understand the difference better.
+
+168
+00:13:02,000 --> 00:13:07,000
+After that, we learn the concept of test doubles and what types of test double's exist.
+
+169
+00:13:07,000 --> 00:13:13,000
+We also learned why and when we need to use test numbers and we learn the advantages of working with
+
+170
+00:13:13,000 --> 00:13:13,000
+them.
+
+171
+00:13:14,000 --> 00:13:20,000
+I explain the different types of integration testing and we discussed different approaches during integration
+
+172
+00:13:20,000 --> 00:13:26,000
+testing and at the end of the lesson we reviewed frameworks for Java that will help us to write integration
+
+173
+00:13:26,000 --> 00:13:27,000
+tests.
+
+174
+00:13:27,000 --> 00:13:29,000
+That said, hope you like the lesson.
+
+175
+00:13:30,000 --> 00:13:33,000
+Thanks a lot for your attention and see you in the next lesson.
+

35 - Integration testing & Mockito/002 Byte-Buddy-agent-library.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://mvnrepository.com/artifact/net.bytebuddy/byte-buddy-agent/1.10.19

35 - Integration testing & Mockito/002 Byte-Buddy-library.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://mvnrepository.com/artifact/net.bytebuddy/byte-buddy/1.10.19

35 - Integration testing & Mockito/002 Mockito Part 1_en.srt

@@ -0,0 +1,1196 @@
+1
+00:00:05,000 --> 00:00:06,000
+Hello, Jim.
+
+2
+00:00:06,000 --> 00:00:11,000
+Glad to see you and this lesson and today we're going to start dive deeper into the details and learn
+
+3
+00:00:11,000 --> 00:00:13,000
+framework for integration testing.
+
+4
+00:00:13,000 --> 00:00:18,000
+Today, we learn McKetta will start from understanding what McKetta library is.
+
+5
+00:00:19,000 --> 00:00:24,000
+After that, we are going to have a lot of real life examples that will help you to understand how to
+
+6
+00:00:24,000 --> 00:00:30,000
+work with Makita API, but to make sure that you can write and run Makita tests will set up your environment
+
+7
+00:00:30,000 --> 00:00:34,000
+first and will add Java libraries to class parts of your project.
+
+8
+00:00:34,000 --> 00:00:40,000
+I will show you how to use Marketo extension for your unit to be able to work with Makita in your unit.
+
+9
+00:00:40,000 --> 00:00:46,000
+Tests will create more books and in real life, examples will verify behavior on our marks.
+
+10
+00:00:46,000 --> 00:00:50,000
+You will learn how much injection works in this lesson.
+
+11
+00:00:50,000 --> 00:00:56,000
+I will show you how you can use argument marchers and what the specifics of using them in Makita tests
+
+12
+00:00:56,000 --> 00:00:57,000
+for specific cases.
+
+13
+00:00:57,000 --> 00:01:03,000
+I will show you how to stop exception when it will be needed and at the end of the lesson will learn
+
+14
+00:01:03,000 --> 00:01:04,000
+how to work with argument.
+
+15
+00:01:04,000 --> 00:01:06,000
+CAPTA, let's start.
+
+16
+00:01:07,000 --> 00:01:11,000
+Makita is a library that is used during unioned and integration testing in Java applications.
+
+17
+00:01:12,000 --> 00:01:15,000
+Makita is used to create Mock's based on the interfaces.
+
+18
+00:01:15,000 --> 00:01:22,000
+With the help of this library, we can stop some great spice and does behavior during integration of
+
+19
+00:01:22,000 --> 00:01:23,000
+different components.
+
+20
+00:01:23,000 --> 00:01:28,000
+Makita has a really nice API that helps us to write nice and readable tasks.
+
+21
+00:01:29,000 --> 00:01:32,000
+And today on real examples, I'm going to show you how to work with McKetta.
+
+22
+00:01:33,000 --> 00:01:36,000
+Let's jump to Eclipse and not Makita on examples.
+
+23
+00:01:36,000 --> 00:01:42,000
+I prepared real life example to help you understand the API before the Makita API.
+
+24
+00:01:43,000 --> 00:01:46,000
+I will give you a context of our classes that we are going to test.
+
+25
+00:01:47,000 --> 00:01:49,000
+Imagine that we have messenger class.
+
+26
+00:01:49,000 --> 00:01:53,000
+This class aggregates template engine and mail server.
+
+27
+00:01:53,000 --> 00:01:59,000
+Template engine is a type that can prepare content for your email message based on the template, and
+
+28
+00:01:59,000 --> 00:02:05,000
+the client will take information from client object and pasted in the template and return ready to send
+
+29
+00:02:05,000 --> 00:02:06,000
+message.
+
+30
+00:02:06,000 --> 00:02:12,000
+You know this kind of emails that contains personalized information like your first and last name,
+
+31
+00:02:12,000 --> 00:02:13,000
+for example.
+
+32
+00:02:13,000 --> 00:02:18,000
+I didn't implement all logic here because for the sake of our market examples, that wouldn't mean a
+
+33
+00:02:18,000 --> 00:02:19,000
+lot.
+
+34
+00:02:19,000 --> 00:02:25,000
+So I'm one of you understand at least high level logic client is a regular object that can be created
+
+35
+00:02:25,000 --> 00:02:29,000
+only with email and can return its email when needed.
+
+36
+00:02:29,000 --> 00:02:32,000
+The next field in messenger type is email server.
+
+37
+00:02:32,000 --> 00:02:35,000
+Object of this type has only one goal.
+
+38
+00:02:35,000 --> 00:02:41,000
+Be able to send the message from specific person to the specific addressee with a personalized message
+
+39
+00:02:41,000 --> 00:02:49,000
+content sent massive takes object of type email to send the message email object in our particular case
+
+40
+00:02:49,000 --> 00:02:51,000
+has a message, content and address.
+
+41
+00:02:52,000 --> 00:02:56,000
+We have getters and setters here for mail server and template engine.
+
+42
+00:02:56,000 --> 00:02:59,000
+And here is our key message and messenger service.
+
+43
+00:02:59,000 --> 00:03:00,000
+It is called Send Message.
+
+44
+00:03:01,000 --> 00:03:04,000
+This method takes client object and template object.
+
+45
+00:03:04,000 --> 00:03:06,000
+At the beginning we create message content.
+
+46
+00:03:06,000 --> 00:03:13,000
+After that we create email object and set content and Andrassy to email and after that we call send
+
+47
+00:03:13,000 --> 00:03:14,000
+with email object.
+
+48
+00:03:15,000 --> 00:03:17,000
+Hope you understand the context.
+
+49
+00:03:17,000 --> 00:03:19,000
+And now let me ask you a few questions.
+
+50
+00:03:19,000 --> 00:03:25,000
+How would you test that when you call, send the message Masset on messenger then send message of mail
+
+51
+00:03:25,000 --> 00:03:30,000
+server is invoked to be sure that integration between messenger and mail server works.
+
+52
+00:03:31,000 --> 00:03:36,000
+How would you test that mail server is invoked with the email object that contains email that we get
+
+53
+00:03:36,000 --> 00:03:38,000
+from the client object.
+
+54
+00:03:38,000 --> 00:03:44,000
+And to be sure that this is not just a random email object, would you like to check when you call,
+
+55
+00:03:44,000 --> 00:03:48,000
+send messages and prepare a message of template engine objects is invoked.
+
+56
+00:03:48,000 --> 00:03:52,000
+Can you take a minute and think of different cases that you would like to test?
+
+57
+00:03:52,000 --> 00:03:58,000
+We have to test interconnection behavior and how components behave in different cases based on different
+
+58
+00:03:58,000 --> 00:04:00,000
+output of connected objects.
+
+59
+00:04:01,000 --> 00:04:07,000
+Now, when we have the context about our system, let's write this with the help of the library and
+
+60
+00:04:07,000 --> 00:04:11,000
+the first thing we have to do is to add external library to our project.
+
+61
+00:04:12,000 --> 00:04:17,000
+If you so lesson about Holmquist, I already showed how to download the library from my own repository
+
+62
+00:04:17,000 --> 00:04:20,000
+and edit as external library to the project.
+
+63
+00:04:20,000 --> 00:04:21,000
+No, you have to do the same.
+
+64
+00:04:21,000 --> 00:04:26,000
+But just download other libraries, find Marketo core and download library.
+
+65
+00:04:27,000 --> 00:04:32,000
+You can download from Mavin Repository, have a live link to this library and the lesson attachments.
+
+66
+00:04:32,000 --> 00:04:38,000
+So don't worry, you just have to download jar of the latest version and add it has external library
+
+67
+00:04:38,000 --> 00:04:38,000
+to our project.
+
+68
+00:04:39,000 --> 00:04:42,000
+Pay attention that this library has dependencies.
+
+69
+00:04:42,000 --> 00:04:45,000
+Click on the compatible version and make sure you download it.
+
+70
+00:04:45,000 --> 00:04:48,000
+Also these libraries and added them to a class.
+
+71
+00:04:49,000 --> 00:04:54,000
+In this particular lesson, we are not using the building tools that will significantly help us with
+
+72
+00:04:54,000 --> 00:04:59,000
+managing dependencies, but we will learn this bill to use a little bit later in our course.
+
+73
+00:04:59,000 --> 00:05:03,000
+Also, besides this libraries, please download my Kitajima.
+
+74
+00:05:03,000 --> 00:05:08,000
+Jupiter Library, all links, you will find interesting attachments, so don't worry about that.
+
+75
+00:05:09,000 --> 00:05:15,000
+I have added all these jurors to the glass parts of my project, and now we can proceed with the examples.
+
+76
+00:05:16,000 --> 00:05:21,000
+Here's our test, you know, where you can see a lot of different annotations, but don't worry, we'll
+
+77
+00:05:21,000 --> 00:05:23,000
+learn all of them gradually as we go.
+
+78
+00:05:24,000 --> 00:05:25,000
+Let's create our first test.
+
+79
+00:05:26,000 --> 00:05:27,000
+We want to test it.
+
+80
+00:05:27,000 --> 00:05:33,000
+Mansehra will actually send email when I will call, send a message message on my messenger object.
+
+81
+00:05:33,000 --> 00:05:34,000
+Let's write this test.
+
+82
+00:05:35,000 --> 00:05:41,000
+For the first test, I have to create concerns for some text message and some random email in my condition.
+
+83
+00:05:41,000 --> 00:05:45,000
+Part of the test I create client object was a random email.
+
+84
+00:05:45,000 --> 00:05:49,000
+Also, I create some template object to use it during the testing.
+
+85
+00:05:50,000 --> 00:05:54,000
+After that, I want to create a stop for this specific test.
+
+86
+00:05:54,000 --> 00:06:00,000
+I want to imitate the next scenario when prepare message will be called on template engine object with
+
+87
+00:06:00,000 --> 00:06:02,000
+a specific template and with my client.
+
+88
+00:06:02,000 --> 00:06:05,000
+Then I will return some random message.
+
+89
+00:06:05,000 --> 00:06:12,000
+Important thing here is to understand that after this line, no matter how much time someone will prepare
+
+90
+00:06:12,000 --> 00:06:17,000
+a message with these objects, I will get these random message for all other arguments.
+
+91
+00:06:17,000 --> 00:06:19,000
+Template engine will return now.
+
+92
+00:06:19,000 --> 00:06:26,000
+In other words, the default value for type that is returned from this method for all reference types.
+
+93
+00:06:26,000 --> 00:06:28,000
+This value is now here.
+
+94
+00:06:28,000 --> 00:06:29,000
+I left a command line.
+
+95
+00:06:29,000 --> 00:06:35,000
+When you get the source code, you can uncommon this line to make sure what is returned after this method
+
+96
+00:06:35,000 --> 00:06:37,000
+and location with new parameters.
+
+97
+00:06:38,000 --> 00:06:40,000
+But let's stop on this line before moving further.
+
+98
+00:06:41,000 --> 00:06:44,000
+Let me explain to you what is happening here.
+
+99
+00:06:44,000 --> 00:06:49,000
+When is a static method from Makita class to stop massas on UniMac?
+
+100
+00:06:49,000 --> 00:06:54,000
+Pay attention that on the top of my file I need a static input of everything.
+
+101
+00:06:54,000 --> 00:06:55,000
+What is inside my class?
+
+102
+00:06:56,000 --> 00:07:00,000
+That's why I can call one method without specifying much the class name.
+
+103
+00:07:00,000 --> 00:07:04,000
+The next thing I have here is a method and location on mock object.
+
+104
+00:07:04,000 --> 00:07:08,000
+Based on this, we need to have AMOC from the previous class.
+
+105
+00:07:08,000 --> 00:07:13,000
+And you already know that Mock allows us to test behavior during the interaction with other components.
+
+106
+00:07:13,000 --> 00:07:20,000
+For example, we will do this in the next lines, but at this very moment we need to stop specific behavior.
+
+107
+00:07:21,000 --> 00:07:25,000
+Why I need to start behavior and why I just can't use real object.
+
+108
+00:07:25,000 --> 00:07:29,000
+Well, there are different reasons why we might want to do like this.
+
+109
+00:07:29,000 --> 00:07:31,000
+The first reason is the simplest one.
+
+110
+00:07:32,000 --> 00:07:37,000
+By the moment you write this test, you don't have any implementation of template engine at all.
+
+111
+00:07:38,000 --> 00:07:42,000
+The only thing what you have is interface of type, template engine.
+
+112
+00:07:43,000 --> 00:07:48,000
+And implementation of this interface is in progress by as a developer from your team, for example,
+
+113
+00:07:48,000 --> 00:07:53,000
+the second reason to stop MassArt on the mark is that you are going to perform a lot of different tasks
+
+114
+00:07:54,000 --> 00:07:59,000
+and you want to reproduce different cases to understand how program behaves based on the different state
+
+115
+00:07:59,000 --> 00:08:02,000
+of other components that it interacting with.
+
+116
+00:08:02,000 --> 00:08:08,000
+It is a good way to test edge values and all classes of equivalent probably have the one question in
+
+117
+00:08:08,000 --> 00:08:11,000
+a hat how to create mock.
+
+118
+00:08:11,000 --> 00:08:13,000
+There are different ways to create more energy.
+
+119
+00:08:13,000 --> 00:08:20,000
+And for Energy Unit five, I wrote and commented all possible ways to create more so you can use this
+
+120
+00:08:20,000 --> 00:08:22,000
+file as a cheat sheet in the future.
+
+121
+00:08:22,000 --> 00:08:28,000
+The first way to create more is to call Mauck method from Makita class and pass the user interface with
+
+122
+00:08:28,000 --> 00:08:30,000
+specific class just like this.
+
+123
+00:08:31,000 --> 00:08:34,000
+The second option is to use more connotation above the field that you want to mock.
+
+124
+00:08:35,000 --> 00:08:40,000
+In this particular case, I have to put more concentration right above my field and now I have to call
+
+125
+00:08:41,000 --> 00:08:44,000
+it Marks Masset from Makita annotations class and pass the reference.
+
+126
+00:08:44,000 --> 00:08:46,000
+The object of this test class.
+
+127
+00:08:47,000 --> 00:08:50,000
+If you would use this method, you would find that it works just perfect.
+
+128
+00:08:51,000 --> 00:08:55,000
+But developers of the library consider this method as deprecated.
+
+129
+00:08:55,000 --> 00:08:57,000
+I would dive into the details.
+
+130
+00:08:57,000 --> 00:08:59,000
+Why exactly they marked it as deprecated?
+
+131
+00:09:00,000 --> 00:09:04,000
+Because probably it wouldn't mean a lot for us right now what they recommend to use.
+
+132
+00:09:04,000 --> 00:09:10,000
+Instead, it is recommended to use open source method, it turns out to closable.
+
+133
+00:09:10,000 --> 00:09:15,000
+I saw this reference in a variable and in after each method I close it.
+
+134
+00:09:15,000 --> 00:09:18,000
+You can use this option if you wish and last.
+
+135
+00:09:18,000 --> 00:09:23,000
+But most convenient option, in my opinion, is to use Makita extension for Unit five.
+
+136
+00:09:24,000 --> 00:09:30,000
+We have to place extant with annotation above our class and pass the class of McKetta extension.
+
+137
+00:09:30,000 --> 00:09:36,000
+Make sure that your implicit all library is to a class pass properly was all necessary dependencies.
+
+138
+00:09:36,000 --> 00:09:41,000
+In case you use this extension, you shouldn't use any static methods that I would just share it with
+
+139
+00:09:41,000 --> 00:09:42,000
+you.
+
+140
+00:09:42,000 --> 00:09:48,000
+This is pretty convenient, in my opinion, in jail for you to use special rounds that is called market.
+
+141
+00:09:48,000 --> 00:09:52,000
+As a unit runner, we would use Macchi through all the options.
+
+142
+00:09:52,000 --> 00:09:53,000
+Works fine.
+
+143
+00:09:53,000 --> 00:09:58,000
+Just on the matter of your current style and specifics of your test, how exactly you would like to
+
+144
+00:09:58,000 --> 00:10:04,000
+initialize mops, but now you know all possible ways to create Mock's, that is for sure.
+
+145
+00:10:05,000 --> 00:10:06,000
+Also, one more thing.
+
+146
+00:10:06,000 --> 00:10:12,000
+It is a rule of thumb to specify that some specific object is a mark by adding more suffix to a variable
+
+147
+00:10:12,000 --> 00:10:13,000
+name like this.
+
+148
+00:10:14,000 --> 00:10:20,000
+So now when you know how to create marks in test with the help of McKetta, let's get back to the place
+
+149
+00:10:20,000 --> 00:10:22,000
+where we stopped here.
+
+150
+00:10:22,000 --> 00:10:28,000
+In one method, I could prepare a message on my mark and pass specific client and specific template.
+
+151
+00:10:29,000 --> 00:10:35,000
+And after that I call Zenovich on MassArt and I pass the value that has compatable.
+
+152
+00:10:35,000 --> 00:10:41,000
+I was returned value of prepared message Massett, this is a value that I expect to be returned by my
+
+153
+00:10:41,000 --> 00:10:45,000
+Molk when I will call prepare a message with this client and this template.
+
+154
+00:10:46,000 --> 00:10:47,000
+Let's perform some action.
+
+155
+00:10:47,000 --> 00:10:50,000
+We call, send a message message on our messenger object.
+
+156
+00:10:50,000 --> 00:10:54,000
+I put the same client and template that I used during Stahmann.
+
+157
+00:10:55,000 --> 00:10:57,000
+Now it is time to perform verifications.
+
+158
+00:10:58,000 --> 00:11:04,000
+The first things that I wanted to test is that after call send message Zapopan message method of template
+
+159
+00:11:04,000 --> 00:11:11,000
+engine is code with the same client and template that I used to send message and location.
+
+160
+00:11:11,000 --> 00:11:18,000
+How to do that I call static Masset verified from McKetta class and I pass mark of template engine that
+
+161
+00:11:19,000 --> 00:11:22,000
+you already saw how I initialized Mauck of template engine.
+
+162
+00:11:23,000 --> 00:11:28,000
+The most interesting part is how to test integration between messenger and template engine.
+
+163
+00:11:29,000 --> 00:11:35,000
+It sounds like a good idea to inject template engine into the messenger object to make sure that it
+
+164
+00:11:35,000 --> 00:11:37,000
+uses exactly smok.
+
+165
+00:11:38,000 --> 00:11:43,000
+This will help me to come up with the right conclusion about integration between these two modules.
+
+166
+00:11:43,000 --> 00:11:48,000
+How to do that with McKetta, would you a field of type messenger?
+
+167
+00:11:48,000 --> 00:11:53,000
+That would be our test instance and I would inject more connotation right above this field.
+
+168
+00:11:54,000 --> 00:11:54,000
+What does it mean?
+
+169
+00:11:55,000 --> 00:12:01,000
+First of all, object of this type will be created and all models that are declared in this test class
+
+170
+00:12:01,000 --> 00:12:07,000
+and that are at the same time compatible with the fields declared in messenger type will be injected
+
+171
+00:12:07,000 --> 00:12:07,000
+there.
+
+172
+00:12:08,000 --> 00:12:11,000
+Let me show you my messenger class has two fields.
+
+173
+00:12:11,000 --> 00:12:16,000
+One field is of type template engine and the second field is of type server.
+
+174
+00:12:17,000 --> 00:12:19,000
+OK, let's get back to our test class.
+
+175
+00:12:19,000 --> 00:12:23,000
+In our test class, I have most of template engine in the mail server.
+
+176
+00:12:24,000 --> 00:12:30,000
+This means that these two marks will be injected in this object market is smart enough to understand
+
+177
+00:12:30,000 --> 00:12:37,000
+this and it takes care about this that tries to perform an action with the help of the setters.
+
+178
+00:12:37,000 --> 00:12:44,000
+But even in case there are no setters, Makita will try to inject it with the constructor and even Zano
+
+179
+00:12:44,000 --> 00:12:46,000
+constructor was all necessary fields.
+
+180
+00:12:46,000 --> 00:12:53,000
+Makita will use mechanism of reflection and inject these marks a bit later in this course will be on
+
+181
+00:12:53,000 --> 00:12:57,000
+reflection mechanism so that you would also be able to create your own McKetta.
+
+182
+00:12:58,000 --> 00:13:04,000
+I believe you understand that these two marks will be injected in our test instance, and I want to
+
+183
+00:13:04,000 --> 00:13:08,000
+verify that repair method was invoked on template and an object.
+
+184
+00:13:08,000 --> 00:13:11,000
+Moakes, allow me to verify the behavior.
+
+185
+00:13:11,000 --> 00:13:17,000
+So in my test, after passing Mark to verify method, I invoke repair method with a specific arguments
+
+186
+00:13:17,000 --> 00:13:24,000
+that I expect to be there, for example, in case I would pass here new object of client, not the one
+
+187
+00:13:24,000 --> 00:13:26,000
+I used during the send message invocation.
+
+188
+00:13:27,000 --> 00:13:30,000
+The test will fail and this is supercool.
+
+189
+00:13:30,000 --> 00:13:34,000
+Can you see how I test interconnection between two classes?
+
+190
+00:13:34,000 --> 00:13:37,000
+I checked after passing arguments to one class.
+
+191
+00:13:37,000 --> 00:13:40,000
+The method of another class was exactly the same.
+
+192
+00:13:40,000 --> 00:13:41,000
+Arguments is invoked.
+
+193
+00:13:42,000 --> 00:13:48,000
+What I can also test here, I can test that same method was invoked on my mind server, mock the same
+
+194
+00:13:48,000 --> 00:13:49,000
+syntax.
+
+195
+00:13:49,000 --> 00:13:55,000
+The only difference here is that I don't know what an object will be here because in my object is created
+
+196
+00:13:55,000 --> 00:13:56,000
+inside the method.
+
+197
+00:13:57,000 --> 00:14:01,000
+For the sake of this particular test, I don't care what object to send there.
+
+198
+00:14:02,000 --> 00:14:08,000
+What I am interested in is to verify that method sent, was invoked, was actually an email.
+
+199
+00:14:09,000 --> 00:14:13,000
+The new things that you can see here is that I called any it what is it.
+
+200
+00:14:14,000 --> 00:14:16,000
+This is so called argument moccia.
+
+201
+00:14:17,000 --> 00:14:20,000
+This is a static method that returns Makita argument moccia.
+
+202
+00:14:20,000 --> 00:14:22,000
+Let me explain how this work.
+
+203
+00:14:23,000 --> 00:14:29,000
+There may be cases when in our test we have to respond to a wider range of values of before and unknown
+
+204
+00:14:29,000 --> 00:14:30,000
+values.
+
+205
+00:14:30,000 --> 00:14:34,000
+Let's review the same test method, but with argument matchers.
+
+206
+00:14:34,000 --> 00:14:41,000
+The first thing you can see that I use any method with other classes I can do this with any reference
+
+207
+00:14:41,000 --> 00:14:45,000
+is Stipe's when I don't care about the actual value that is passed to the masses.
+
+208
+00:14:46,000 --> 00:14:52,000
+There are also different modules that you can use some of them and string any Ayinde and in Dumble,
+
+209
+00:14:52,000 --> 00:14:56,000
+any char, any boolean, at least any set, any map and so on.
+
+210
+00:14:56,000 --> 00:15:00,000
+You can just start typing any and look at the other suggestion.
+
+211
+00:15:00,000 --> 00:15:06,000
+The important thing you have to remember here is that it is impossible to use arguments marchers for
+
+212
+00:15:06,000 --> 00:15:07,000
+only few arguments.
+
+213
+00:15:07,000 --> 00:15:12,000
+If you use arguments much for one argument, then you have to use it for all arguments.
+
+214
+00:15:13,000 --> 00:15:19,000
+For example, in case you want to stop Massett invocation with specifying real client object and argument,
+
+215
+00:15:19,000 --> 00:15:23,000
+much of a template marketable through an exception you can check.
+
+216
+00:15:24,000 --> 00:15:29,000
+But what to do in case you want to use specific first argument and any argument of compatible type for
+
+217
+00:15:29,000 --> 00:15:30,000
+the second argument.
+
+218
+00:15:31,000 --> 00:15:36,000
+In this case, you have to use equal argument moccia in case you execute this statement.
+
+219
+00:15:36,000 --> 00:15:37,000
+It will work as expected.
+
+220
+00:15:38,000 --> 00:15:42,000
+Just pass objects that you want to use for equality verification.
+
+221
+00:15:42,000 --> 00:15:43,000
+And that's it.
+
+222
+00:15:43,000 --> 00:15:44,000
+That was easy.
+
+223
+00:15:44,000 --> 00:15:45,000
+I agree.
+
+224
+00:15:46,000 --> 00:15:51,000
+Also, Makita provides other marchers like is a that takes some classes.
+
+225
+00:15:51,000 --> 00:15:54,000
+An argument is now is not null marches.
+
+226
+00:15:54,000 --> 00:15:57,000
+That takes regular expression as an argument.
+
+227
+00:15:57,000 --> 00:15:58,000
+Is that clear.
+
+228
+00:15:58,000 --> 00:16:04,000
+A lot of marches are self-described Mezquita developers did a great job by providing us with a library
+
+229
+00:16:04,000 --> 00:16:06,000
+that can help us to create readable tests.
+
+230
+00:16:07,000 --> 00:16:13,000
+Are the important things to remember is that you can't use argument marchers as a return on values and
+
+231
+00:16:13,000 --> 00:16:15,000
+exact value is required here.
+
+232
+00:16:15,000 --> 00:16:20,000
+And also you can't use argument much outside of verification or STEINMANN.
+
+233
+00:16:20,000 --> 00:16:25,000
+That is the raftis argument marchers were often in the past.
+
+234
+00:16:25,000 --> 00:16:31,000
+My personal opinion is that in the case you use argument marcha in your test, that means you don't
+
+235
+00:16:31,000 --> 00:16:33,000
+care about arguments for this specific test case.
+
+236
+00:16:34,000 --> 00:16:37,000
+My personal opinion, again, this is ridiculous.
+
+237
+00:16:37,000 --> 00:16:42,000
+In case you don't care about arguments in your test case, then why you should care about this test
+
+238
+00:16:42,000 --> 00:16:43,000
+at all.
+
+239
+00:16:43,000 --> 00:16:44,000
+Just remove it.
+
+240
+00:16:44,000 --> 00:16:45,000
+It doesn't matter.
+
+241
+00:16:45,000 --> 00:16:52,000
+Well, using marchers is so popular across developers, I can't hide my misunderstanding of using them
+
+242
+00:16:52,000 --> 00:16:57,000
+because in the test I want to make sure that I control my test flow from the beginning to the end,
+
+243
+00:16:58,000 --> 00:17:04,000
+including all arguments that my impact on behavior of my unit or on interaction between my units.
+
+244
+00:17:04,000 --> 00:17:09,000
+So it is up to you as a to use argument munchers and my case a test and how often to use them.
+
+245
+00:17:09,000 --> 00:17:14,000
+But you know, my opinion, OK, probably this is time to move to our next test.
+
+246
+00:17:15,000 --> 00:17:20,000
+Now, I want to test it in case for some reason, Template Engine will throw a legal argument exception
+
+247
+00:17:20,000 --> 00:17:23,000
+send message method won't be executed till the end.
+
+248
+00:17:23,000 --> 00:17:24,000
+How to verify this?
+
+249
+00:17:25,000 --> 00:17:29,000
+I already have template engine mock injected into my messenger object.
+
+250
+00:17:29,000 --> 00:17:34,000
+So the only thing I have to do now is to stop, prepare a message and make sure that it was through.
+
+251
+00:17:34,000 --> 00:17:35,000
+And the legal argument exception.
+
+252
+00:17:35,000 --> 00:17:39,000
+When I work, prepare a message, my assertion will test that.
+
+253
+00:17:39,000 --> 00:17:43,000
+The legal argument exception is from when I call prepare a message.
+
+254
+00:17:43,000 --> 00:17:50,000
+This test shows us that in case error happens in template engine, then messenger wouldn't work too.
+
+255
+00:17:50,000 --> 00:17:53,000
+And we can't successfully verify this interaction.
+
+256
+00:17:53,000 --> 00:17:56,000
+Now, one of the most interesting tests.
+
+257
+00:17:56,000 --> 00:17:57,000
+Let's now test and even.
+
+258
+00:17:58,000 --> 00:18:04,000
+It was created instant message Macit, I want to be sure that client's email address is set to email
+
+259
+00:18:04,000 --> 00:18:12,000
+object and underseas is correct, but not just a random one, but how I would tell this if email object
+
+260
+00:18:12,000 --> 00:18:18,000
+is created inside the send message, how to get access to it to provide us with amazing tools, that
+
+261
+00:18:18,000 --> 00:18:19,000
+is called argument.
+
+262
+00:18:19,000 --> 00:18:25,000
+Capturing this tool allows us to capture arguments that was passed during the massive invocation and
+
+263
+00:18:25,000 --> 00:18:27,000
+after that to be able to verify its state.
+
+264
+00:18:28,000 --> 00:18:29,000
+Let me show you how to do this.
+
+265
+00:18:30,000 --> 00:18:34,000
+The first thing we have to do is to declare a field of special type in our test.
+
+266
+00:18:34,000 --> 00:18:37,000
+This type is called argument capture.
+
+267
+00:18:37,000 --> 00:18:41,000
+It is parametrized by the type that we want to capture in the argument.
+
+268
+00:18:42,000 --> 00:18:47,000
+And that's the important thing here, is to use special annotation to tell Makita that this is an object
+
+269
+00:18:47,000 --> 00:18:48,000
+that will capture arguments.
+
+270
+00:18:49,000 --> 00:18:52,000
+And you can see I have capture annotation here.
+
+271
+00:18:52,000 --> 00:18:57,000
+Now we are going to proceed the first part of this test we have already discussed.
+
+272
+00:18:57,000 --> 00:18:59,000
+Let's focus on the assertion part.
+
+273
+00:18:59,000 --> 00:19:06,000
+I also verify that message was invoked and after that I will fight that sent method of mail server object
+
+274
+00:19:06,000 --> 00:19:07,000
+was called.
+
+275
+00:19:07,000 --> 00:19:14,000
+And instead of parsing arguments much easier, I object of my capture and kill capture method so that
+
+276
+00:19:14,000 --> 00:19:19,000
+it could capture arguments that was passed to this method during the runtime.
+
+277
+00:19:19,000 --> 00:19:26,000
+After a captured argument, I can extract the value from my capture my colon, get value Massett and
+
+278
+00:19:26,000 --> 00:19:27,000
+that's it.
+
+279
+00:19:27,000 --> 00:19:33,000
+Now I have reference to email object that was created inside the method and I can get and receive from
+
+280
+00:19:33,000 --> 00:19:39,000
+this object and compare it was expected value and expect its value would be clients.
+
+281
+00:19:39,000 --> 00:19:39,000
+Email.
+
+282
+00:19:40,000 --> 00:19:42,000
+How do you feel the like Makita.
+
+283
+00:19:42,000 --> 00:19:45,000
+I'm glad that we started this topic with you.
+
+284
+00:19:45,000 --> 00:19:51,000
+We still have a lot of things to learn, including advanced McKetta features, but I suggest to call
+
+285
+00:19:51,000 --> 00:19:53,000
+it today and proceed in the next lesson.
+
+286
+00:19:54,000 --> 00:19:57,000
+Right now, let's recap what we have learned today.
+
+287
+00:19:57,000 --> 00:19:58,000
+In this lesson.
+
+288
+00:19:58,000 --> 00:20:04,000
+We learned what Markkula Library is and why we need it and in which cases we can figure it out.
+
+289
+00:20:04,000 --> 00:20:07,000
+Development environment to be able to use Makita.
+
+290
+00:20:07,000 --> 00:20:09,000
+You learned all necessary libraries.
+
+291
+00:20:09,000 --> 00:20:12,000
+You have to add to your project to use Marketo features.
+
+292
+00:20:12,000 --> 00:20:15,000
+Now you know how to use Marketo extension for your unit.
+
+293
+00:20:16,000 --> 00:20:20,000
+I showed you how to create Mok's in your test and verify their behavior.
+
+294
+00:20:20,000 --> 00:20:26,000
+With the help of tutor on real life examples, you saw how to inject more to our test instance.
+
+295
+00:20:26,000 --> 00:20:32,000
+Also, you learned how to use different argument matchers and at the end of the lesson you saw how to
+
+296
+00:20:32,000 --> 00:20:37,000
+use argument capture to capture arguments that are to our marks during the runtime.
+
+297
+00:20:37,000 --> 00:20:38,000
+That's it for today.
+
+298
+00:20:39,000 --> 00:20:40,000
+Thanks a lot for your attention.
+
+299
+00:20:40,000 --> 00:20:43,000
+Have a great day and see you in the next lesson.
+

35 - Integration testing & Mockito/002 Mockito-JUnit-Jupiter.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://mvnrepository.com/artifact/org.mockito/mockito-junit-jupiter/3.7.7

35 - Integration testing & Mockito/002 Mockito-core-library.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://mvnrepository.com/artifact/org.mockito/mockito-core/3.7.7

35 - Integration testing & Mockito/002 Objenesis-library.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://mvnrepository.com/artifact/org.objenesis/objenesis/3.1