1
00:00:00,000 --> 00:00:04,000
Welcome to the testing world in this session.

2
00:00:04,000 --> 00:00:12,000
We need to understand what is software testing, so we are going to understand this process in three

3
00:00:12,000 --> 00:00:13,000
steps.

4
00:00:14,000 --> 00:00:20,000
So first of all, we start with software testing can be defined as a process, but does the application

5
00:00:20,000 --> 00:00:22,000
under different conditions?

6
00:00:22,000 --> 00:00:24,000
OK, here we need to understand.

7
00:00:24,000 --> 00:00:26,000
What do you mean by the different conditions?

8
00:00:27,000 --> 00:00:27,000
OK.

9
00:00:27,000 --> 00:00:33,000
Let me move to my application and here I'm just logging out.

10
00:00:33,000 --> 00:00:38,000
So that's my application, and I'm on the login page of my application.

11
00:00:39,000 --> 00:00:44,000
Now I have a task to test this login functionality of the application.

12
00:00:45,000 --> 00:00:50,000
So my first condition would be I'm just putting correct username and correct password.

13
00:00:51,000 --> 00:00:52,000
That's my first condition.

14
00:00:53,000 --> 00:00:56,000
No, in this case, users should be logged in.

15
00:00:57,000 --> 00:01:04,000
Then I'm going for second condition in which I'm giving correct username but incorrect password.

16
00:01:05,000 --> 00:01:12,000
We should not login in that third condition could be we are giving incorrect username, but correct

17
00:01:12,000 --> 00:01:12,000
password.

18
00:01:13,000 --> 00:01:15,000
No, I'm trying to log in.

19
00:01:15,000 --> 00:01:17,000
So that's my third condition now.

20
00:01:17,000 --> 00:01:23,000
My fourth condition is I'm just leaving username bank and giving the correct password.

21
00:01:24,000 --> 00:01:26,000
Now I'm going to check.

22
00:01:26,000 --> 00:01:33,000
So if you see, we're testing our application with different conditions and these conditions involved

23
00:01:33,000 --> 00:01:36,000
positive as well as negative conditions.

24
00:01:36,000 --> 00:01:38,000
Positive means we're giving correct input.

25
00:01:38,000 --> 00:01:40,000
We are following correct steps.

26
00:01:40,000 --> 00:01:44,000
Negative means we are giving incorrect input, incorrect steps.

27
00:01:45,000 --> 00:01:53,000
So here first step is software testing can be defined as a process in which we test our application

28
00:01:53,000 --> 00:01:55,000
under different conditions.

29
00:01:56,000 --> 00:01:59,000
Second is over a period of time.

30
00:02:00,000 --> 00:02:05,000
OK, what does it mean if we started the application today?

31
00:02:06,000 --> 00:02:10,000
Maybe after one month, you get some functionality to test.

32
00:02:10,000 --> 00:02:12,000
So I take an example of the project.

33
00:02:12,000 --> 00:02:14,000
You started on 1st 1st of Gen.

34
00:02:14,000 --> 00:02:18,000
We got the registration page on 1st of Web to test it.

35
00:02:19,000 --> 00:02:21,000
Now we complete the testing of that page.

36
00:02:21,000 --> 00:02:24,000
It's not like we will not start again.

37
00:02:24,000 --> 00:02:31,000
We have to test the same thing again and again many times until we deliver that application to the client.

38
00:02:32,000 --> 00:02:37,000
So we are testing that same thing over a period of time again and again in the cyclically.

39
00:02:38,000 --> 00:02:42,000
So perform testing in the cyclically until you deliver application to the client.

40
00:02:43,000 --> 00:02:48,000
And third point, which is most important evaluating the result.

41
00:02:49,000 --> 00:02:49,000
OK.

42
00:02:49,000 --> 00:02:50,000
What does it mean?

43
00:02:51,000 --> 00:02:58,000
It means whenever we are testing, we have two outputs.

44
00:02:59,000 --> 00:03:02,000
One is expected result and other what is actually the third?

45
00:03:03,000 --> 00:03:04,000
OK.

46
00:03:05,000 --> 00:03:09,000
Let me take you to one more scenario.

47
00:03:10,000 --> 00:03:14,000
So I'm here on the on another application and there is a search functionality.

48
00:03:15,000 --> 00:03:21,000
OK, I'm searching here, iPhone as I click on the search button.

49
00:03:22,000 --> 00:03:28,000
We should get some results, but I'm getting only one result is this functional is working correctly

50
00:03:29,000 --> 00:03:30,000
because we are getting results.

51
00:03:31,000 --> 00:03:33,000
So is this is it working correctly?

52
00:03:33,000 --> 00:03:35,000
I don't know, because it might be possible.

53
00:03:36,000 --> 00:03:39,000
As expected, we should get five result, but we are getting only one result.

54
00:03:40,000 --> 00:03:50,000
So the point is, before going for the testing, we should have expected results and these expected

55
00:03:50,000 --> 00:03:52,000
results will come from the client requirement.

56
00:03:52,000 --> 00:03:55,000
So first of all, we understand the client requirement.

57
00:03:55,000 --> 00:04:00,000
And from there, we get expert result when we are testing our application.

58
00:04:01,000 --> 00:04:07,000
We're getting actual results at the end of each scenario, which we are testing.

59
00:04:07,000 --> 00:04:10,000
We're comparing actual results with expected results.

60
00:04:11,000 --> 00:04:17,000
If it is passed, then testing as fast as it is filled, so expect a result is taken from the client

61
00:04:17,000 --> 00:04:18,000
requirement.

62
00:04:18,000 --> 00:04:21,000
Actual results coming from the application.

63
00:04:21,000 --> 00:04:26,000
When we are testing, we need to compare and evaluate it is bust or not.

64
00:04:28,000 --> 00:04:34,000
So here, if I take an example, my expected result was when you search for the iPhone, we should get

65
00:04:34,000 --> 00:04:35,000
five results.

66
00:04:35,000 --> 00:04:36,000
We should get five iPhones.

67
00:04:37,000 --> 00:04:41,000
But we are getting only one means testing is available here.

68
00:04:42,000 --> 00:04:47,000
But if you're expecting only one result and we are getting one result means testing is passed.

69
00:04:48,000 --> 00:04:49,000
So here what?

70
00:04:49,000 --> 00:04:54,000
Each testing which we are doing, we need to compare results with expected result.

71
00:04:56,000 --> 00:04:59,000
So here we have seen a basic definition, a practical definition.

72
00:05:00,000 --> 00:05:05,000
Also, software testing here, we understand software testing with three simple points.

73
00:05:06,000 --> 00:05:08,000
That's all we have for the session.