Web Automation-Selenium-Ruby|E-2-E Cucumber integration-15hr

discover how ruby defines classes as containers for variables, constants, methods, and constructors, create objects with class_name.new, and access members through those objects, plus require and lib folder organization.

Define and use methods in Ruby by creating classes, writing def methods, passing arguments, making reusable code, importing files, and calling methods via object instances.

Define Ruby methods that take arguments to multiply numbers, call with 10 and 50 for 500, and learn how extra or missing arguments affect results.

learn to design reusable Ruby methods that take arguments, return values, and be composed by passing the multiplied result to an addition method, demonstrating returning vs displaying and method calls.

Learn the difference between instance methods and class methods in Ruby, where instances require an object and class methods are accessed by the class name, with definition approaches using self.

Explore implementing Ruby methods for basic arithmetic, creating separate addition, subtraction, and multiplication methods that return values and reuse results for subsequent calculations.

Master metaprogramming by implementing three methods to square a value, cube a value, and sum their results, demonstrated with inputs 2 and 3 yielding 4, 27, and 31.

Learn how constructors in Ruby are automatically called when an object is created. Place initialization code in the constructor using the initialize keyword, just like methods.

Demonstrates a constructor with and without arguments, showing how to pass two arguments during object creation to perform subtraction and display the result.

Learn how constructors initialize code and start the browser before executing tests. Understand that creating an object triggers the constructor, automatically starting the browser so the test runs with readiness.

Explore Ruby condition handling with if else, nested if, and or/and conditionals to determine even or odd numbers using modulo. Learn how single equals assigns and double equals compares.

Explore condition handling with if, else if, and else to manage multiple conditions, including negative numbers, zero, and checking even or odd.

Explains nested if condition handling by implementing a method that grades a number using thresholds of 50 and 90, with pass, pass with honors, or fail outcomes.

Master condition handling with or in ruby by implementing a method that checks if a number is greater than 50 or even, and acts when a condition is met.

Learn to handle conditions with the conditional and, requiring both criteria—such as a number greater than 50 and even—and distinguish or logic using test examples.

Practice task demonstrates condition handling by creating a class with a method that takes three numbers a, b, and c to determine the largest and, separately, the smallest.

Write a method that takes a number and prints if it is divisible by 5, by 11, or by both, with messages for each case.

Create a class method that accepts a month number, validates it against 0 and 12, and determines the days in that month, with February noted as a special case.

Develop a method that takes three arguments for the triangle's side lengths and checks whether the triangle is equilateral or isosceles.

Write a method that accepts five subject marks for physics, chemistry, biology, mathematics, and computers. Validate 0–100 for each, compute a percentage, and display grades f to a.

Explore Ruby variable types, including local, instance, class, and global variables, and understand their scopes. Local variables stay in a method; instance, class, and global variables span objects and classes.

Understand local variables in Ruby, declared inside a method and scoped to that method, and that they must start with a lowercase letter or underscore.

Learn how instance variables in Ruby are declared inside a class and accessible across methods within the same object, unlike local variables that stay inside a method.

Explore class variables in Ruby, declared with @@, accessible across a class and by all objects, sharing values unlike instance variables that belong to one object.

Global variables in Ruby are declared with a dollar sign and can be used anywhere, inside or outside a class, across files after loading.

Learn Ruby for loop basics, including syntax, ranges (1..10 and 1...10), do/end usage, and printing i, plus building a class to generate a number table.

Learn how the break keyword exits a for loop in ruby, via a 1 to 10 range and a number table, stopping when a value is divisible by 5.

Explore how the next keyword in a for loop skips the remaining iterations when a number is divisible by five, displaying only numbers not divisible by five.

Learn how the redo keyword repeats the same loop iteration in Ruby's for loop, creating deliberate re-entries and possible infinite loops, alongside next and break concepts.

Practice task demonstrates swapping two method arguments. Start with a temporary variable, then swap without one, using 10 and 20 as inputs.

Demonstrate generating a series by adding the last two numbers, starting from default values, yielding 1, 2, 3, 5, 8, 13 in this programming session.

Write a method that takes one number as input and checks whether it is a prime number, displaying a prime number or not a prime number accordingly.

Practice task: print a rectangular ASCII box on the output screen using a for loop, four lines, with six stars on the top and bottom and spaces inside.

Create a method that takes one argument to print a table of numbers not divisible by 3, 5, or 7, then print the reverse: numbers divisible by them.

Explore the while loop in ruby, mirroring c, c++, java, and c#, and learn to start, end, and increment or decrement to generate a table.

Learn how the until loop works in ruby and how it differs from the while loop, using examples that run until the condition becomes false.

Learn Ruby each loop syntax with ranges, including the last and excluding the last, and implement a class method to generate and print a multiplication table from 1 to 10.

Learn to implement a fibonacci-like series up to 100 in Ruby, starting with 0 and 1, and create a method that generates a number of terms with a while loop.

Display a triangle by using nested for loops to print an increasing number of stars per line, switch lines, and clear the screen between steps in a simple rhythm.

Display a triangle pattern by printing leading spaces per line with a pre-space loop, then a star, decreasing spaces from five on line one to one.

Explore nested loops in practice task 15 as you generate star patterns, starting with one star and building to three-star and five-star triangles.

Practice session teaches how to print a number triangle across lines, starting with 1 on the first line and increasing on each subsequent line, a hands-on programming exercise.

Engage in a time for practice task that generates a triangle by looping through numbers from one to ten, displaying each new number in sequence.

Practice creating a hollow triangle of stars using loops and conditional logic, placing stars at the corners and base while developing control flow and pattern printing techniques.

Discover array basics in Ruby: an ordered data structure that holds multiple data types, supports zero-based and negative indexing, and returns nil for invalid indices.

Explore creating and manipulating arrays in Ruby: access elements by zero-based or negative indices, fetch ranges, and resize arrays while setting default values.

This lecture covers common array methods like at for indexed access, first and last for ends, fetch the first three values, drop values, and length or count to determine size.

Learn common Ruby array methods such as push, insert at the end and at a specific index, and sort, with notes on the deprecated pop.

Learn how to use the each loop with arrays (and hashes) in Ruby to iterate values, print results, and perform calculations like summing or multiplying elements.

Summing all numeric values in an array demonstrates a robust approach to handle arrays of any size in a test automation context.

Practice task teaches how to locate the largest value in a data area and then identify the smallest value from that same area, using an example dataset like Gnumeric.

Create an array of values and determine the second largest and second smallest numbers in this simple practice task.

Develop a practice-driven approach to verify the presence and frequency of a value within a data area by building a class and a parameterized method.

Identify all even values in the area, such as 22 and 44, and then identify the odd values, including 1, 3, 40, 45, and 33.

Practice numeric data handling by creating an array, storing numbers, and sorting them in ascending and descending order, then displaying the results.

Understand strings in Ruby, including single-quoted and double-quoted forms, variable substitution, and three ways to create strings.

Learn to apply common string functions from the string class, including uppercase, lowercase, length, and concatenation, by transforming strings and combining them with the plus operator and the concat method.

Explore Ruby string functions such as lstrip, strip, and chop, and learn to remove leading or trailing spaces and the last character, and check length to verify results.

Explore seven common string functions in Ruby, including reverse, insert, repeat, replace, substitution, count, and split, with practical examples.

Explore string functions by extracting substrings by index, finding index positions, and comparing strings with double equals and case-insensitive comparisons.

Practice string comparison by ignoring spaces and case to determine equality between two strings with leading or trailing spaces.

Engage in task 26 of string handling by reversing a string without the reverse function, building skills from previous lessons on string manipulation.

practice task that checks whether a given string is a palindrome using a string handling method; learn to identify palindromic words by analyzing start and end characters.

Practice task 28 teaches string handling by checking if a second string exists in a first string and counting its occurrences.

Create a Ruby method that takes two string arguments, concatenates them with a space, computes the resulting length, and displays the final string as in the hello world example.

Practice building a method that accepts a string, counts the words, and identifies duplicate words; demonstrate with examples where all words are unique or some words repeat.

Create a method that accepts a string and removes all spaces, whether at the start, middle, or end. Then compute removed spaces by comparing original and final lengths.

Create a method that formats any input string by alternating lowercase and capitalized words: first word lowercase, second capitalized, third lowercase, fourth capitalized, and so on.

Practice string handling by comparing only the first three characters of two strings, ignoring case, to determine if they match.

Implement two string methods: compare the last ten characters of two strings, ignoring case, and compare the last n characters using a numeric parameter.

A practice task builds a Ruby class with a method that accepts a string and prints each character on a new line, illustrating string handling for web automation.

Explore how hashes in Ruby store data as unique key-value pairs, access values by key, and customize defaults with constructors, including creating hashes and handling nil when keys are missing.

Explore three Ruby hash creation approaches, including hash literals, Hash.new construction, and default values. Learn how to insert keys and values, fetch data, and understand nil versus custom defaults.

Learn common hash methods in Ruby: length/size to count items, keys and values to retrieve data, and key? to check key existence, with adding items illustrated.

Create a Ruby hash with symbols as keys, learn that symbols start with a colon, and understand that symbols share a single memory location for efficient access.

Learn to use the each loop with a Ruby hash to iterate over key-value pairs, access keys and values, and print them with correct syntax.

Create a hash with five numeric keys and values, iterate through it with a loop, and output the sum of all values.

Create a hash with unique keys and numeric values. Then implement logic to identify the maximum and minimum values from the hash.

Learn to read data from a file in Ruby using the File class, open method, and modes like r and a, then read lines with readline until end-of-file.

Learn how to write data to a file in Ruby using the File class, opening in write, write-and-read, or append modes, creating files if needed and closing after writing.

Read data from one file and write it to another using file objects, a read loop, and a write operation, demonstrating data copying between files.

Read data from two source files and merge it into a third file, demonstrating file handling by writing combined content to the final file.

Practice task reads data from specific lines, selects values from odd or even lines, and prints the ordered data to the console, reinforcing line-based data extraction for test automation.

Read data from a file, scan each line for the word error, and skip lines containing it, displaying only lines without errors; redefine the check to filter out error lines.

Copy only lines without the text error from one file to another, creating a test file with errors and transferring the clean lines to a final file in file handling.

Read data from one file, convert it to uppercase, and append the result to the end of the file while applying the same process to another file.

Develop a nested class with file handling methods. Read the first five lines, read the last five lines, and read a given number of lines based on an argument.

Learn how Ruby models are .rb files whose module name matches the Ruby filename and starts with a capital letter, and how importing a model runs its executable code automatically.

Explore module and model methods in Ruby within a Selenium and Cucumber workflow, including how executable code runs on import and module methods are called via module name :: method.

Shows how to define a class inside a module, create objects, and call class methods, while illustrating module methods, constructors, and object instantiation in Ruby.

Learn how to structure submodules by nesting models within a main model, create objects from submodels, and call methods to execute code in selenium ruby automation.

Create a simple task by building a model inside a model, adding a class, and defining methods; then instantiate the class from another file to call these methods.