It is very important to have multiple layers of testing. To me if you are only testing it
yourself, there will be a good bit of errors that you did not see because you were the one
who made the software. You would have somewhat of a tunnel vision. I'm not saying that
you would miss you would miss all of them. I am saying that it is always good to get fresh
eyes. And if we are looking at it as there are multiple layers to a program, then you
definitely need to test as you go. So, going into that, I would test as I go. I would also get a
team together to also test the program. I would probably put it out as a beta. I like the beta
idea because now you have people who are actually interested in what you have created.
This will give you the input you actually need to get it to perfection. What they like and
you know you are definitely going to be told what they found wrong and do not like. It is
always important to have multiple levels of testing. Very often each test done is designed to
test a specific function or area of a system and to ensure it meets requirements and
functions as it should. We often then go in and make changes to those processes in the
system. The importance of multilevel testing is that when we do make these adjustments,
we may not necessarily see the second or third order effects in the systems. It may affect
part of the process down the line that we did not see with the tests we ran earlier. Multiple
levels of testing are key. Three test activities that should be done are planning, analysis and
implementation. Planning allows us to determine the scope and objectives of the testing
phase and outline what the goals are for the testing. It also allows us to plan and schedule
our testing which is key on larger projects. Analysis is always a crucial part of testing and it
covers 2 different things. One is to analyze the areas that need to be tested most and how to
test them. The other portion covers test results and how to make the necessary corrections if
there are any. Implementing the test is when we take all of our test planning and put it into
motion. This is when we ensure the tests are run correctly and targeting the specific
functions that needed to be tested. Having different levels of testing is very important part
of software development. It helps to ensure performance, compatibility and security. The
levels of testing that are necessary are, unit testing, integration testing, system testing and
acceptance testing. Unit testing, focuses on one part at a time of the software to make sure
it is doing the job that it's suppose to. Integration testing, makes sure that different working
parts of the soft ware can properly work together. System testing is making sure it works
from start to finish. Acceptance testing, is usually done by the costumer to make sure it
meets the needs that they asked for. Testing is done until expectations are met. The
software has to be deliverable, meaning that the customer paid the developer for a product
that does what they asked, so it must meet at least that expectation. some important test
activities are, planning and analysis; design and implementation; evaluation and report. The
planning and analysis stage, is about planning out the whole schedule of tests and analyzing
and mitigating all risks involved. The design and implementation phase, tests are designed
and implemented accordingly. Finally in the evaluation and report phase, is self
explanatory, tests are evaluated what has been done and if there are any other adjustments
to be made. Then it is noted and reported. Having different levels of testing is critical to
software development. One style of testing isn’t sufficient to highlight all the potential bugs
or issues. If a company doesn’t utilize multiple testing cycles and methods, it could be very
risky.
There are 4 different levels of testing: unit testing, integration testing, system testing, and
acceptance. Unit testing focuses on specific parts or components of the software and tests
them with all cases that might happen in a real-time scenario. Integration testing is where it
combines all the modules of software and test to see if they work with each other as
intended. System testing is the process where it tests the entire project from start to finish.
Finally, acceptance is where the company verifies if the software meets the companies’
requirements.Three testing activities are also initiated to be compliant with the companies’
needs and aligns with their goals. These activities are planning and analysis, design and
implementation, and evaluation and report. During the planning and analysis phase, this is
where the team tries to analyze the program for many different scenarios and try to find any
“breaks” in the software. Design and implementation are where tests are designed to
identify the test environment and then implement according to it. Finally, evaluation and
report is when they gather all the data and results from the tests and then implement any
changes necessary to mend the software. Software testing at various stages is essential since
it lowers the chance of mistakes. Another advantage is ensuring that the customer's
demands are met. Every level of software testing helps developers assess the program's
features and determine if it satisfies the client's or consumer's needs. An application's flaws
and mistakes may be found using a variety of tests before it is deployed and put into large-
scale production. Static testing, unit testing, integration testing, system testing, and
acceptance testing are the five stages of software testing.Planning and managing, analyzing
and creating, and implementing and carrying out are the three main tasks involved in
software testing. The needs and properties of the software are established during the
planning and control phase. At this stage, the project's completion specifications are also
established. Analysis and design, which comes after that, include assessing the program and
choosing a framework for various design methodologies. The design must be put into
practice in accordance with the plan in order to satisfy the client's requirements. The project
is then completed in accordance with the client's requirements. I was recently working on
building the code for a user interface on a bank app or an atm. It was just the basic code
mostly. The code I had created allow the user to create an account and access an existing
account. once having account some things, you could do were checking your account
balance, depositing and withdrawing from the account. When first created I would do some
basic testing to make sure that the function I had created actually did what they were
intended to do. My first round of testing I would finish a function and hit F5 (i was using
visual studio) to open the test environment and I would test the function to see what it did. I
would do this for every function trying to find defects or errors.When I created the rules for
creating passwords in the account creation function, I would purposely not follow the rules,
I set in an attempted to break it while in the testing environment.eventually after is was
more fleshed out I would have friends and family play with and try to do different things to
cause bugs or errors to appear.I had my uncle who was an experienced developer go thru
the code find error or bugs. he would also help me find more efficient ways to do things
too.I had done developer testing, user testing, bug testing, and input testing during the
process of create it. Because of how complicated the written code can get, testing at
different levels is extremely important to save time and energy later in the process, you
don't want to get to the end and a module with 1000 lines of code and it doesn't output the
correct information.Before releasing to a client testing of the system, and checking that the
systems functions meets the clients requirements would be two big ones. These would
ensure that it is working properly, and has the right needs of the client. Installation tests
would be good to run as well to ensure a the software can run on the devices the client was
targeting. Security tests would also be a good test to check if the system deals with a lot of
sensitive information. Testing each step added with unit testing helps make sure that part
works before moving on, you don't want to get many lines in with a bunch of "If"
statements and then need to go back and test each one afterwards. Testing during
integration of the modules ensures that the code calls up the correct functions and the
correct outputs are being delivered from that part. Then a system test would ensure that
everything is working correctly from beginning to end, this would test every part of the
system to find other bugs or hitches that need to be looked into and fixed. Catching bugs as
soon as possible means it is easier to fix. When a bug is in the code for some time,
forgetfulness becomes the irresponsible half. Spending too much time observing the code
will have extra effects. The longer it becomes, the most significant impact it will have on
the behavior of the bug.
Several levels of testing can be used to catch bugs before they hatch. Unit testing to system
and acceptance not only clarifies the tiniest bit of code but can routinely test the whole
system.
The testing activities I can implement are:
Exhaustive Testing
Test all the possibilities.
Black-Box Testing
Pretend to ignore the contents inside the black box. There is an idea of what it does but
can't figure out how to use it. Testing various methods to know what will tick its inputs.
White-Box Testing
The inside of the structure is known and how it works. The additional knowledge for the
design of the tester can implement how to crash it.
Gray-Box Testing
White and Black box testing are both implemented. Some methods of testing are known but
not all. How to attack it is partially known.
When you need to make sure that something is working well, you have to try multiple
times to see if the device or in this care the software will break with certain amount of
pressure. This way you can know where you got to work on it to fix it with patches or
updates as needed.
If one was just to make sure that a program was to work at its basic level, they may miss
loop holes or even glitches that will cause the program to be dismantle as its being used by
someone who is not the main programmer.
The 3 test that one has to do to make sure of it is as follow :
1. Integration testing- You have to make sure that it works well with the system that
you are connected to and making sure that no other programs failure when added to
any OS you built it for.
2. Performance testing - It easy for a program if there are 20 people looking at it
carefully when they do what they know to do on the app, but it's much more
difficult when you have millions of people checking it out and possibly sending
reports back of when the device breaks down.
3. Acceptance testing- This is done once you have fully found satisfaction of the
product to then allow it to go into the world. As my company calls it, it has to be
the MVP, minimal viable product.
