Programming/Bash - Revision history

Brodriguez: Move unittesting contents to new page

2020-10-25T20:58:32Z

Move unittesting contents to new page

← Older revision		Revision as of 20:58, 25 October 2020
Line 231:		Line 231:

	== Unit Testing ==		== Unit Testing ==
	~~The UnitTesting I've found in Bash is to use '''Bats'''. Full description found at https://opensource.com/article/19/2/testing-bash-bats.~~		See [[Programming/Bash/Unit Testing\|Unit Testing]].

	~~Effectively, first add~~ [[Programming/~~Git Submodules\|Git Submodules]]:~~
	~~git submodule add https://github.com/sstephenson/bats tests/libs~~/~~bats~~
	~~git submodule add https://github.com/ztombol/bats-assert tests/libs/bats-assert~~
	~~git submodule add https://github.com/ztombol/bats-support tests/libs/bats-support~~
	~~git commit~~


	~~=== Functions ===~~
	~~Can initialize functions that run at the start and end of every test with:~~

	~~###~~
	~~# This will run at the start of every test.~~
	##
	~~setup () {~~
	~~# Setup logic here.~~
	}

	~~###~~
	~~# This will run at the end of every test.~~
	##
	~~teardown () {~~
	~~# Teardown logic here.~~
	}

	~~Create actual tests with:~~
	~~@test "<name_of_test>" {~~
	~~# Test logic here.~~
	}

	~~=== Assertion Statements ===~~
	~~As of writing this, possible assertion statements appear to be:~~
	~~# Assert success.~~
	~~assert <command>~~

	~~# Assert failure.~~
	~~refute <command>~~

	~~# Assert two values are equal.~~
	~~assert_equal <val_1> <val_2>~~

	~~# Assert function succeeds (returns 0).~~
	~~assert_success <function_call>~~

	~~# Assert function fails (returns 1).~~
	~~assert_failure <function_call>~~

	~~# Assert that a variable called '''${output}''' matches the expected value.~~
	~~assert_output <expected_value>~~

	~~# Assert that a variable called '''${output}''' does not match the expected value.~~
	~~refute_output <expected_value>~~

	~~# Assert that a given line appears in "output". {{ Todo~~ \| ~~is this a variable? Or actual echo output? }}~~
	~~assert_line <line_to_match>~~

	~~# Assert that a given line does not appear in "output". {{ Todo \| is this a variable? Or actual echo output? }}~~
	~~refute_line <line_to_match>~~

	~~=== Other Assertions ===~~
	~~It's possible to also do assertions via standard if statement syntax. Simply include the condition clause but nothing else.~~

	~~Ex:~~
	~~# Check if '''${my_var}''' is equal to 5.~~
	~~[[ ${my_var} == 5 ]]~~

	~~# Check if '''${my_var}''' does not match the string "This is a string."~~
	~~[[ ${my_var} != "This is a string." ]]~~

	~~# Check if '''${some_number}''' is greater than 5.~~
	~~[[ ${some_number} > 5~~ ]]

	~~If any of these checks were to fail, then the test itself would stop on the given line and return a failure~~.

Brodriguez: Document assertions

2020-10-25T20:55:27Z

Document assertions

← Older revision		Revision as of 20:55, 25 October 2020
Line 238:		Line 238:
	git submodule add https://github.com/ztombol/bats-support tests/libs/bats-support		git submodule add https://github.com/ztombol/bats-support tests/libs/bats-support
	git commit		git commit


			=== Functions ===
			Can initialize functions that run at the start and end of every test with:

			###
			# This will run at the start of every test.
			##
			setup () {
			# Setup logic here.
			}

			###
			# This will run at the end of every test.
			##
			teardown () {
			# Teardown logic here.
			}

			Create actual tests with:
			@test "<name_of_test>" {
			# Test logic here.
			}

			=== Assertion Statements ===
			As of writing this, possible assertion statements appear to be:
			# Assert success.
			assert <command>

			# Assert failure.
			refute <command>

			# Assert two values are equal.
			assert_equal <val_1> <val_2>

			# Assert function succeeds (returns 0).
			assert_success <function_call>

			# Assert function fails (returns 1).
			assert_failure <function_call>

			# Assert that a variable called '''${output}''' matches the expected value.
			assert_output <expected_value>

			# Assert that a variable called '''${output}''' does not match the expected value.
			refute_output <expected_value>

			# Assert that a given line appears in "output". {{ Todo \| is this a variable? Or actual echo output? }}
			assert_line <line_to_match>

			# Assert that a given line does not appear in "output". {{ Todo \| is this a variable? Or actual echo output? }}
			refute_line <line_to_match>

			=== Other Assertions ===
			It's possible to also do assertions via standard if statement syntax. Simply include the condition clause but nothing else.

			Ex:
			# Check if '''${my_var}''' is equal to 5.
			[[ ${my_var} == 5 ]]

			# Check if '''${my_var}''' does not match the string "This is a string."
			[[ ${my_var} != "This is a string." ]]

			# Check if '''${some_number}''' is greater than 5.
			[[ ${some_number} > 5 ]]

			If any of these checks were to fail, then the test itself would stop on the given line and return a failure.

Brodriguez: Start unittesting docs

2020-10-25T20:38:28Z

Start unittesting docs

← Older revision		Revision as of 20:38, 25 October 2020
Line 228:		Line 228:
	# Outputs "/home/user/"		# Outputs "/home/user/"
	${file_name%%my_dir/*}		${file_name%%my_dir/*}


			== Unit Testing ==
			The UnitTesting I've found in Bash is to use '''Bats'''. Full description found at https://opensource.com/article/19/2/testing-bash-bats.

			Effectively, first add [[Programming/Git Submodules\|Git Submodules]]:
			git submodule add https://github.com/sstephenson/bats tests/libs/bats
			git submodule add https://github.com/ztombol/bats-assert tests/libs/bats-assert
			git submodule add https://github.com/ztombol/bats-support tests/libs/bats-support
			git commit

Brodriguez: Brodriguez moved page Bash to Programming/Bash

2020-10-25T17:27:11Z

Brodriguez moved page Bash to Programming/Bash

← Older revision

Revision as of 17:27, 25 October 2020

Brodriguez: Add note about @ variable

2020-10-07T10:15:14Z

Add note about @ variable

← Older revision		Revision as of 10:15, 7 October 2020
Line 62:		Line 62:
	echo $1 # Prints out "test".		echo $1 # Prints out "test".
	echo $2 # Prints out "5".		echo $2 # Prints out "5".

			You can also get all passed variables in array format, with the {{ ic \|<nowiki>${@}</nowiki>}} variable.

Brodriguez: Document dictionaries and update arrays

2020-10-07T10:12:47Z

Document dictionaries and update arrays

← Older revision		Revision as of 10:12, 7 October 2020
Line 138:		Line 138:
	Arrays in Bash are one of the only variable types that require the [[Bash#Variable Usage\|bracket syntax]].		Arrays in Bash are one of the only variable types that require the [[Bash#Variable Usage\|bracket syntax]].

	~~===== Single Index Access =====~~		To append new index values, use:
	~~The syntax to access an array is as follows~~:		my_array+=<value>
	~~# Update index 1.~~
	my_array~~[1]~~=~~"New Value"~~

	~~# Read index 1.~~		To read all values in the array, use:
	~~echo~~ ${my_array[1]}		${my_array[@]}

	~~===== Full Array Access =====~~		To read a single index, use:
	~~Note that some programming languages will let you see the full array if you don't provide an~~ index ~~value. This is not the case in Bash.~~		${my_array[<index>]}

	~~For example, the following will only display the first~~ index, ~~and nothing else~~:		To update a single index, use:
	~~echo $~~my_array		my_array[<index>]=<value>

	~~To properly show the full~~ array~~, instead use~~ the ~~index of '''@'''~~.		Bash arrays aren't meant to be mutable, and thus don't really have a good way to remove an index. The best alternative is to create a second array that only has the values you want.
	~~echo ${my_array[@]}~~

	=== Dictionaries ===		=== Dictionaries ===
			Dictionaries can be incredibly powerful. See [[Dictionaries]] for more info.

			==== Declaring Dictionaries ====
			Dictionaries in Bash are called "associative arrays" and are declared with the following:
			declare -A my_dict

			==== Accessing Dictionary Values ====
			To set new key-value pairs, use:
			# Set multiple key-value pairs.
			my_dict=( [<key_1>]=<value_1> [<key_2>]=<value_2> )

			# Set a single key-value pair.
			my_dict[<key>]=<value>

			To read all key-value pairs, use:
			# Expand all keys in pair.
			${!my_dict[@]}

			# Expand all values in pair.
			${my_dict[@]}

			To read a value in a key-value pair, use:
			${my_dict[<key>]}

			To update an existing key-value pair, use
			my_dict[<key>]=<value>

			Bash arrays aren't meant to be mutable, and thus don't really have a good way to remove an index. The best alternative is to create a second array that only has the values you want.

	~~=== Structs ===~~

	== String Manipulation ==		== String Manipulation ==

Brodriguez: Create arrays section

2020-10-07T09:49:57Z

Create arrays section

@@ Line 15: / Line 15: @@
 However, there is a hackish way to implement them anyways, according to https://stackoverflow.com/a/43158193
-{ warn | It's recommended to use multiple inline comments instead, as this may not always work with all systems. }
+{{ warn | It's recommended to use multiple inline comments instead, as this may not always work with all systems. }}
   : '
   This is a block comment.
@@ Line 32: / Line 32: @@
 === Variable Usage ===
   echo "Printing variable values."
   echo $a_bool
@@ Line 106: / Line 109: @@
 Essentially, each function is almost treated as a new instance of a bash script. So functions use the same syntax to [[Bash#Passing Variables into the Script|pass variables into the script.]]
-For example, if we have `test_function` and we want to pass two variables, then the code may look like this:
+For example, if we have '''test_function''' and we want to pass two variables, then the code may look like this:
    function test_function () {
       var_1=$1
@@ Line 118: / Line 121: @@
   test_function $some_var_1 $some_var_2
 == String Manipulation ==

Brodriguez: Create local variables section

2020-10-07T09:15:39Z

Create local variables section

← Older revision		Revision as of 09:15, 7 October 2020
Line 36:		Line 36:
	echo $b_bool		echo $b_bool
	echo ${my_var_1}${my_var_2}		echo ${my_var_1}${my_var_2}

			=== Local Variables ===
			By default, any variable in a bash script is a global variable. {{ todo \| Link to "global/local variable" documentation. }} To limit a variable to local scope, use the '''local''' syntax.

			For example, below defines two variables with a value of "5". One is global and one is local:
			my_global_var=5
			local my_local_var=5

	=== Passing Variables into the Script ===		=== Passing Variables into the Script ===
Line 45:		Line 52:
	This will pass in the arguments of "test" and "5" into your script.		This will pass in the arguments of "test" and "5" into your script.

	=== Accessing Variables Passed into the Script ===		==== Accessing Variables Passed into the Script ====
	You access passed variables via the dollar sign, followed by the argument number.		You access passed variables via the dollar sign, followed by the argument number.

Brodriguez: Document functions

2020-10-07T09:08:30Z

Document functions

← Older revision		Revision as of 09:08, 7 October 2020
Line 87:		Line 87:
	echo $item		echo $item
	done		done


			== Functions ==
			function <function_name> () {
			# Function logic here.
			}

			=== Passing Parameters ===
			Passing variables into functions in Bash is a bit...obtuse, for lack of a better word.

			Essentially, each function is almost treated as a new instance of a bash script. So functions use the same syntax to [[Bash#Passing Variables into the Script\|pass variables into the script.]]

			For example, if we have `test_function` and we want to pass two variables, then the code may look like this:
			function test_function () {
			var_1=$1
			var_2=$2
			}

			To call this function, we would have code like this:
			some_var_1="test"
			some_var_2=5
			...
			test_function $some_var_1 $some_var_2

Brodriguez: Document passing in variables

2020-10-07T09:03:36Z

Document passing in variables

@@ Line 23: / Line 23: @@
 == Variables ==
 === Variable Definition ===
   a_bool=true
@@ Line 34: / Line 36: @@
   echo $b_bool
   echo ${my_var_1}${my_var_2}
 == If Statements ==