Modularity-driven testing - Revision history

Cngzz1: Rearrange article to give the introduciton more information

2023-07-08T05:21:40Z

Rearrange article to give the introduciton more information

← Previous revision		Revision as of 05:21, 8 July 2023
Line 1:		Line 1:
		⚫	'''Modularity-driven testing''' is a term used in the testing of [[software]]. The test [[Script (computer programming)\|script]] modularity [[Software framework\|framework]] requires the creation of small, independent scripts that represent modules, sections, and functions of the application-under-test. These small scripts are then used in a hierarchical fashion to construct larger tests, realizing a particular test case.<ref>{{Cite book \|last1=DESAI \|first1=SANDEEP \|url=https://books.google.com/books?id=B4sQDAAAQBAJ&dq=Modularity-driven+testing+framework&pg=PA157 \|title=SOFTWARE TESTING : A Practical Approach \|last2=SRIVASTAVA \|first2=ABHISHEK \|date=2016-01-30 \|publisher=PHI Learning Pvt. Ltd. \|isbn=978-81-203-5226-1 \|language=ar}}</ref>
	'''Modularity-driven testing''' is a term used in the testing of [[software]].

	==Background==		==Background==
⚫	The test [[Script (computer programming)\|script]] modularity [[Software framework\|framework]] requires the creation of small, independent scripts that represent modules, sections, and functions of the application-under-test. These small scripts are then used in a hierarchical fashion to construct larger tests, realizing a particular test case.<ref>{{Cite book \|last1=DESAI \|first1=SANDEEP \|url=https://books.google.com/books?id=B4sQDAAAQBAJ&dq=Modularity-driven+testing+framework&pg=PA157 \|title=SOFTWARE TESTING : A Practical Approach \|last2=SRIVASTAVA \|first2=ABHISHEK \|date=2016-01-30 \|publisher=PHI Learning Pvt. Ltd. \|isbn=978-81-203-5226-1 \|language=ar}}</ref>

	Of all the frameworks, this one should be the simplest to grasp and master. It is a well-known [[Computer programming\|programming]] strategy to build an abstraction layer in front of a component to hide the component from the rest of the application. This insulates the application from modifications in the component and provides modularity in the application design. The test script modularity framework applies this principle of abstraction or [[encapsulation (computer programming)\|encapsulation]] in order to improve the maintainability and scalability of automated test suites.<ref>{{cite web\|last=Kelly\|first=Michael\|title=Choosing a test automation framework\|website=[[IBM]] \|url=http://www.ibm.com/developerworks/rational/library/591.html\|accessdate=2013-02-22}}</ref>		Of all the frameworks, this one should be the simplest to grasp and master. It is a well-known [[Computer programming\|programming]] strategy to build an abstraction layer in front of a component to hide the component from the rest of the application. This insulates the application from modifications in the component and provides modularity in the application design. The test script modularity framework applies this principle of abstraction or [[encapsulation (computer programming)\|encapsulation]] in order to improve the maintainability and scalability of automated test suites.<ref>{{cite web\|last=Kelly\|first=Michael\|title=Choosing a test automation framework\|website=[[IBM]] \|url=http://www.ibm.com/developerworks/rational/library/591.html\|accessdate=2013-02-22}}</ref>

Citation bot: Alter: url. URLs might have been anonymized. Add: website, authors 1-1. Removed parameters. Some additions/deletions were parameter name changes. | Use this bot. Report bugs. | Suggested by AManWithNoPlan | #UCB_CommandLine

2022-10-24T22:04:07Z

Alter: url. URLs might have been anonymized. Add: website, authors 1-1. Removed parameters. Some additions/deletions were parameter name changes. | Use this bot. Report bugs. | Suggested by AManWithNoPlan | #UCB_CommandLine

← Previous revision		Revision as of 22:04, 24 October 2022
Line 2:		Line 2:

	==Background==		==Background==
	The test [[Script (computer programming)\|script]] modularity [[Software framework\|framework]] requires the creation of small, independent scripts that represent modules, sections, and functions of the application-under-test. These small scripts are then used in a hierarchical fashion to construct larger tests, realizing a particular test case.<ref>{{Cite book \|~~last~~=DESAI \|~~first~~=SANDEEP \|url=https://books.google.com/books?id=B4sQDAAAQBAJ~~&newbks=0&printsec=frontcover&pg=PA157~~&dq=Modularity-driven+testing+framework&hl=en \|title=SOFTWARE TESTING : A Practical Approach \|last2=SRIVASTAVA \|first2=ABHISHEK \|date=2016-01-30 \|publisher=PHI Learning Pvt. Ltd. \|isbn=978-81-203-5226-1 \|language=ar}}</ref>		The test [[Script (computer programming)\|script]] modularity [[Software framework\|framework]] requires the creation of small, independent scripts that represent modules, sections, and functions of the application-under-test. These small scripts are then used in a hierarchical fashion to construct larger tests, realizing a particular test case.<ref>{{Cite book \|last1=DESAI \|first1=SANDEEP \|url=https://books.google.com/books?id=B4sQDAAAQBAJ&dq=Modularity-driven+testing+framework&pg=PA157 \|title=SOFTWARE TESTING : A Practical Approach \|last2=SRIVASTAVA \|first2=ABHISHEK \|date=2016-01-30 \|publisher=PHI Learning Pvt. Ltd. \|isbn=978-81-203-5226-1 \|language=ar}}</ref>

	Of all the frameworks, this one should be the simplest to grasp and master. It is a well-known [[Computer programming\|programming]] strategy to build an abstraction layer in front of a component to hide the component from the rest of the application. This insulates the application from modifications in the component and provides modularity in the application design. The test script modularity framework applies this principle of abstraction or [[encapsulation (computer programming)\|encapsulation]] in order to improve the maintainability and scalability of automated test suites.<ref>{{cite web\|last=Kelly\|first=Michael\|title=Choosing a test automation framework\|url=http://www.ibm.com/developerworks/rational/library/591.html\|accessdate=2013-02-22}}</ref>		Of all the frameworks, this one should be the simplest to grasp and master. It is a well-known [[Computer programming\|programming]] strategy to build an abstraction layer in front of a component to hide the component from the rest of the application. This insulates the application from modifications in the component and provides modularity in the application design. The test script modularity framework applies this principle of abstraction or [[encapsulation (computer programming)\|encapsulation]] in order to improve the maintainability and scalability of automated test suites.<ref>{{cite web\|last=Kelly\|first=Michael\|title=Choosing a test automation framework\|website=[[IBM]] \|url=http://www.ibm.com/developerworks/rational/library/591.html\|accessdate=2013-02-22}}</ref>

	==References==		==References==

Novemberjazz: heading copyedit and book source

2022-10-22T17:52:19Z

heading copyedit and book source

← Previous revision		Revision as of 17:52, 22 October 2022
Line 1:		Line 1:
	'''Modularity-driven testing''' is a term used in the testing of [[software]].		'''Modularity-driven testing''' is a term used in the testing of [[software]].

			==Background==
	==Test Script Modularity Framework==
	The test [[Script (computer programming)\|script]] modularity [[Software framework\|framework]] requires the creation of small, independent scripts that represent modules, sections, and functions of the application-under-test. These small scripts are then used in a hierarchical fashion to construct larger tests, realizing a particular test case.		The test [[Script (computer programming)\|script]] modularity [[Software framework\|framework]] requires the creation of small, independent scripts that represent modules, sections, and functions of the application-under-test. These small scripts are then used in a hierarchical fashion to construct larger tests, realizing a particular test case.<ref>{{Cite book \|last=DESAI \|first=SANDEEP \|url=https://books.google.com/books?id=B4sQDAAAQBAJ&newbks=0&printsec=frontcover&pg=PA157&dq=Modularity-driven+testing+framework&hl=en \|title=SOFTWARE TESTING : A Practical Approach \|last2=SRIVASTAVA \|first2=ABHISHEK \|date=2016-01-30 \|publisher=PHI Learning Pvt. Ltd. \|isbn=978-81-203-5226-1 \|language=ar}}</ref>

	Of all the frameworks, this one should be the simplest to grasp and master. It is a well-known [[Computer programming\|programming]] strategy to build an abstraction layer in front of a component to hide the component from the rest of the application. This insulates the application from modifications in the component and provides modularity in the application design. The test script modularity framework applies this principle of abstraction or [[encapsulation (computer programming)\|encapsulation]] in order to improve the maintainability and scalability of automated test suites.<ref>{{cite web\|last=Kelly\|first=Michael\|title=Choosing a test automation framework\|url=http://www.ibm.com/developerworks/rational/library/591.html\|accessdate=2013-02-22}}</ref>		Of all the frameworks, this one should be the simplest to grasp and master. It is a well-known [[Computer programming\|programming]] strategy to build an abstraction layer in front of a component to hide the component from the rest of the application. This insulates the application from modifications in the component and provides modularity in the application design. The test script modularity framework applies this principle of abstraction or [[encapsulation (computer programming)\|encapsulation]] in order to improve the maintainability and scalability of automated test suites.<ref>{{cite web\|last=Kelly\|first=Michael\|title=Choosing a test automation framework\|url=http://www.ibm.com/developerworks/rational/library/591.html\|accessdate=2013-02-22}}</ref>
Line 12:		Line 12:
	{{DEFAULTSORT:Modularity-Driven Testing}}		{{DEFAULTSORT:Modularity-Driven Testing}}
	[[Category:Software testing]]		[[Category:Software testing]]


	{{comp-sci-stub}}		{{comp-sci-stub}}

BrownHairedGirl: remove links to deleted portals

2019-08-07T12:19:41Z

remove links to deleted portals

← Previous revision		Revision as of 12:19, 7 August 2019
Line 7:		Line 7:

	==References==		==References==

	{{Portal\|Software Testing}}
	{{Reflist}}		{{Reflist}}

Dawynn: Stub-sorting. You can help!

2018-06-14T18:13:24Z

Stub-sorting. You can help!

← Previous revision		Revision as of 18:13, 14 June 2018
Line 14:		Line 14:


	{{stub}}		{{comp-sci-stub}}

Jabberjaw: move portal

2018-06-13T08:11:05Z

move portal

← Previous revision		Revision as of 08:11, 13 June 2018
Line 1:		Line 1:
⚫	{{Portal\|Software Testing}}

	'''Modularity-driven testing''' is a term used in the testing of [[software]].		'''Modularity-driven testing''' is a term used in the testing of [[software]].

Line 9:		Line 7:

	==References==		==References==
		⚫	{{Portal\|Software Testing}}
	{{Reflist}}		{{Reflist}}

Jabberjaw: clean up, removed underlinked tag; add stub; using AWB

2018-06-13T08:10:21Z

clean up, removed underlinked tag; add stub; using AWB

← Previous revision		Revision as of 08:10, 13 June 2018
Line 1:		Line 1:
	{{Underlinked\|date=March 2013}}
	{{Portal\|Software Testing}}		{{Portal\|Software Testing}}

Line 5:		Line 4:

	==Test Script Modularity Framework==		==Test Script Modularity Framework==
	The test [[Script (computer programming)\|script]] modularity [[Software framework\|framework]] requires the creation of small, independent scripts that represent modules, sections, and functions of the application-under-test. These small scripts are then used in a hierarchical fashion to construct larger tests, realizing a particular test case.		The test [[Script (computer programming)\|script]] modularity [[Software framework\|framework]] requires the creation of small, independent scripts that represent modules, sections, and functions of the application-under-test. These small scripts are then used in a hierarchical fashion to construct larger tests, realizing a particular test case.

	Of all the frameworks, this one should be the simplest to grasp and master. It is a well-known [[Computer programming\|programming]] strategy to build an abstraction layer in front of a component to hide the component from the rest of the application. This insulates the application from modifications in the component and provides modularity in the application design. The test script modularity framework applies this principle of abstraction or [[encapsulation (computer programming)\|encapsulation]] in order to improve the maintainability and scalability of automated test suites.<ref>{{cite web\|last=Kelly\|first=Michael\|title=Choosing a test automation framework\|url=http://www.ibm.com/developerworks/rational/library/591.html\|accessdate=2013-02-22}}</ref>		Of all the frameworks, this one should be the simplest to grasp and master. It is a well-known [[Computer programming\|programming]] strategy to build an abstraction layer in front of a component to hide the component from the rest of the application. This insulates the application from modifications in the component and provides modularity in the application design. The test script modularity framework applies this principle of abstraction or [[encapsulation (computer programming)\|encapsulation]] in order to improve the maintainability and scalability of automated test suites.<ref>{{cite web\|last=Kelly\|first=Michael\|title=Choosing a test automation framework\|url=http://www.ibm.com/developerworks/rational/library/591.html\|accessdate=2013-02-22}}</ref>

	==References==		==References==
			{{Reflist}}
	<references />

	{{DEFAULTSORT:Modularity-Driven Testing}}		{{DEFAULTSORT:Modularity-Driven Testing}}
	[[Category:Software testing]]		[[Category:Software testing]]


			{{stub}}

Vmavanti: Disambiguated: framework → Software framework, encapsulation → encapsulation (computer programming)

2018-03-27T22:52:25Z

Disambiguated: framework → Software framework, encapsulation → encapsulation (computer programming)

← Previous revision		Revision as of 22:52, 27 March 2018
Line 5:		Line 5:

	==Test Script Modularity Framework==		==Test Script Modularity Framework==
	The test [[Script (computer programming)\|script]] modularity [[framework]]~~{{dn\|date=March 2018}}~~ requires the creation of small, independent scripts that represent modules, sections, and functions of the application-under-test. These small scripts are then used in a hierarchical fashion to construct larger tests, realizing a particular test case.		The test [[Script (computer programming)\|script]] modularity [[Software framework\|framework]] requires the creation of small, independent scripts that represent modules, sections, and functions of the application-under-test. These small scripts are then used in a hierarchical fashion to construct larger tests, realizing a particular test case.

	Of all the frameworks, this one should be the simplest to grasp and master. It is a well-known [[Computer programming\|programming]] strategy to build an abstraction layer in front of a component to hide the component from the rest of the application. This insulates the application from modifications in the component and provides modularity in the application design. The test script modularity framework applies this principle of abstraction or [[encapsulation]]~~{{dn\|date=March 2018}}~~ in order to improve the maintainability and scalability of automated test suites.<ref>{{cite web\|last=Kelly\|first=Michael\|title=Choosing a test automation framework\|url=http://www.ibm.com/developerworks/rational/library/591.html\|accessdate=2013-02-22}}</ref>		Of all the frameworks, this one should be the simplest to grasp and master. It is a well-known [[Computer programming\|programming]] strategy to build an abstraction layer in front of a component to hide the component from the rest of the application. This insulates the application from modifications in the component and provides modularity in the application design. The test script modularity framework applies this principle of abstraction or [[encapsulation (computer programming)\|encapsulation]] in order to improve the maintainability and scalability of automated test suites.<ref>{{cite web\|last=Kelly\|first=Michael\|title=Choosing a test automation framework\|url=http://www.ibm.com/developerworks/rational/library/591.html\|accessdate=2013-02-22}}</ref>

	==References==		==References==

Leschnei: Disambiguate Script to Script (computer programming) using popups

2018-03-21T02:22:52Z

Disambiguate Script to Script (computer programming) using popups

← Previous revision		Revision as of 02:22, 21 March 2018
Line 5:		Line 5:

	==Test Script Modularity Framework==		==Test Script Modularity Framework==
	The test [[script]]{{dn\|date=~~February~~ 2018}} ~~modularity [[framework]]~~ requires the creation of small, independent scripts that represent modules, sections, and functions of the application-under-test. These small scripts are then used in a hierarchical fashion to construct larger tests, realizing a particular test case.		The test [[Script (computer programming)\|script]] modularity [[framework]]{{dn\|date=March 2018}} requires the creation of small, independent scripts that represent modules, sections, and functions of the application-under-test. These small scripts are then used in a hierarchical fashion to construct larger tests, realizing a particular test case.

	Of all the frameworks, this one should be the simplest to grasp and master. It is a well-known [[Computer programming\|programming]] strategy to build an abstraction layer in front of a component to hide the component from the rest of the application. This insulates the application from modifications in the component and provides modularity in the application design. The test script modularity framework applies this principle of abstraction or [[encapsulation]] in order to improve the maintainability and scalability of automated test suites.		Of all the frameworks, this one should be the simplest to grasp and master. It is a well-known [[Computer programming\|programming]] strategy to build an abstraction layer in front of a component to hide the component from the rest of the application. This insulates the application from modifications in the component and provides modularity in the application design. The test script modularity framework applies this principle of abstraction or [[encapsulation]]{{dn\|date=March 2018}} in order to improve the maintainability and scalability of automated test suites.<ref>{{cite web\|last=Kelly\|first=Michael\|title=Choosing a test automation framework\|url=http://www.ibm.com/developerworks/rational/library/591.html\|accessdate=2013-02-22}}</ref>
	<ref>{{cite web\|last=Kelly\|first=Michael\|title=Choosing a test automation framework\|url=http://www.ibm.com/developerworks/rational/library/591.html\|accessdate=2013-02-22}}</ref>

	==References==		==References==

Onel5969: Disambiguating links to Programming (link changed to Computer programming) using DisamAssist.

2018-02-18T22:13:19Z

Disambiguating links to Programming (link changed to Computer programming) using DisamAssist.

← Previous revision		Revision as of 22:13, 18 February 2018
Line 7:		Line 7:
	The test [[script]]{{dn\|date=February 2018}} modularity [[framework]] requires the creation of small, independent scripts that represent modules, sections, and functions of the application-under-test. These small scripts are then used in a hierarchical fashion to construct larger tests, realizing a particular test case.		The test [[script]]{{dn\|date=February 2018}} modularity [[framework]] requires the creation of small, independent scripts that represent modules, sections, and functions of the application-under-test. These small scripts are then used in a hierarchical fashion to construct larger tests, realizing a particular test case.

	Of all the frameworks, this one should be the simplest to grasp and master. It is a well-known [[programming]] strategy to build an abstraction layer in front of a component to hide the component from the rest of the application. This insulates the application from modifications in the component and provides modularity in the application design. The test script modularity framework applies this principle of abstraction or [[encapsulation]] in order to improve the maintainability and scalability of automated test suites.		Of all the frameworks, this one should be the simplest to grasp and master. It is a well-known [[Computer programming\|programming]] strategy to build an abstraction layer in front of a component to hide the component from the rest of the application. This insulates the application from modifications in the component and provides modularity in the application design. The test script modularity framework applies this principle of abstraction or [[encapsulation]] in order to improve the maintainability and scalability of automated test suites.
	<ref>{{cite web\|last=Kelly\|first=Michael\|title=Choosing a test automation framework\|url=http://www.ibm.com/developerworks/rational/library/591.html\|accessdate=2013-02-22}}</ref>		<ref>{{cite web\|last=Kelly\|first=Michael\|title=Choosing a test automation framework\|url=http://www.ibm.com/developerworks/rational/library/591.html\|accessdate=2013-02-22}}</ref>