Our Partners
|
 Quality Channel Partner of Mercury Interactive Corporation.
 Authorized Educational Partner of Segue Software, Inc.
|
|
|
 |
 |
| CALL 650-961-2044 TO ENROLL |
Advanced Test Automation with Silk
|
(10 sessions: 40 hours)
- Review of fundamentals
- Making testcases more intelligent
- Writing data-driven tests
- Creating user-defined functions
- Applying OOP to window declarations
- Applying OOP to window objects
- Working with custom objects
- Testing Java Applications
- Testing Web Applications
- Using DOM extension for Web testing
Advanced Test Automation with WinRunner
|
(10 sessions: 40 hours)
- Database Checkpoints (Default Check on a Database, Custom Check on a Database). Database Checkpoint Wizard (ODBC (Microsoft Query) Screens, Setting ODBC (Microsoft Query) Options, Specifying an SQL Statement, Connection String, SQL statement); The Edit Check Dialog Box (Specifying which Cells to Check, Specifying the Verification Method, Specifying the Verification Type, Editing the Expected Data, Modifying a Database Checkpoint, Editing Database Checklists, Modifying a Query in an Existing Database Checklist, Modifying the Expected Results of a Database Checkpoint); Parameterizing Database Checkpoints (Parameterized Queries, Creating a Parameterized Database Checkpoint); TSL Functions for Working with ODBC (Connecting to a Database (db_ connect), Executing a Query and Creating a Result Set Based on an SQL Statement (db_ execute_ query), Retrieving Information from the Database, Returning the Value of a Single Field in the Database (db_ get_ field_ value), Returning the Content and Number of Column Headers (db_ get_ headers), Returning the Row Content (db_ get_ row), Writing the Record Set into a Text File (db_ write_ records), Returning the Last Error Message of the Last Operation (db_ get_ last_ error), Disconnecting from a Database (db_ disconnect))
- Checking Web Pages (Checking Standard Frame Properties, Checking Broken Links, Checking the Object Count in Frames, Checking the Structure of Frames, Tables, and Cells, Checking the Content of Frames, Cells, Links, or Images; Checking the Content of Tables, Checking Links and Images in a Frame, Checking the Number of Columns and Rows in a Table, Checking the URL of Links, Checking Source or Type of Images and Image Links, Checking Color or Font of Text Links, Reading All the Text in a Frame or an Object, Reading a Text String from a Frame or an Object, Checking that a Text String Exists in a Frame or an Object, Analyzing Test Results, Viewing Checkpoint Results, Understanding the WDiff Utility, Understanding the Data Comparison Viewer)
- Programming with TSL (Creating User-Defined Functions, Compiled Modules, Calling Functions from External Libraries, Dynamically Loading External Libraries (loading, unloading DLLs), Declaring External Functions in TSL, Windows API Examples)
- Handling Unexpected Events and Errors (Handling Pop- Up Exceptions,Handling TSL Exceptions, Handling Object Exceptions, Handling Web Exceptions)
- Custom Configurations and Startup Tests (Setting Global testing options, Setting testing options from a Test Script, Initializing special configurations, Mapping a Custom Object to a Standard Class, Configuring a Standard or Custom Class, Creating a Permanent GUI Map Configuration)
- Customizing GUI Checks (Creating Custom GUI Checks for Standard Objects: Creating a Capture Function, Creating a Comparison Function, Registering a New Property Check, Associating a New Property Check with a GUI Object Class, Modifying the Default Checks for a GUI Object Class; Creating GUI Checks for Custom Objects: Adding a Custom GUI Object Class for Verification, Defining a Custom Check for a Custom GUI Object Class; Adding a New GUI Object Class for Verification: Creating Capture and Comparison Functions, Registering the New Check, Setting the Default Checks)
Load Testing of WEB applications with LoadRunner
|
(10 sessions: 40 hours)
This course covers issues of load testing and functional testing under load for intranet and Internet client/server systems. This course focuses on emulating real users, and teaches students to use LoadRunner tools to create Virtual Users, run load test scenarios, analyze and interpret load test results.
- Planning the Load Test (The importance of planning, Analyzing and formatting system usage information, Determining fields to parameterize and the data to use).
- Creating Web Virtual Users (Recording user actions, Measuring specific business processes, Parameterizing input data, Verifying functionality under load, Verifying correct Vuser execution)
- LoadRunner Scenarios (Defining and connecting to hosts, Defining Vusers and scripts, Options and run-time settings for specific purposes)
- Analyze Scenario Execution (Troubleshooting Vuser concurrency issues, Isolating top time transactions, Scenario and cross-scenario graphs and reports)
- Advanced Topics (How VuGen records and replays user actions, Capturing dynamic values, Adding logic to the Vuser, Making output logs more descriptive, Emulating different IP addresses during load testing)
(5 sessions: 20 hours)
- Unix Structure: Operating System, File System, Unix Directories-Files-Inodes, Unix programs
- Shells. Built-in Commands, Environment Variables, The Bourne Shell, The C Shell
- Text Processing. Text Editor - vi, Overview of regular expressions, Text Processing commands
- Usefull Commands. Working with files, File Archiving and Compression, Remote Conection
- Basics of Shell programming. Overview of Shell Scripting
(10 sessions: 40 hours)
- Steps in creating a Shell Script
- Reading user input
- Arithmetic
- Positional parameters and command line arguments
- Conditional constructs and flow control(The test command, The if command, File testing, The case command, The null command)
- Looping commands (for loop, while loop, until loop, shift command, break command, continue command)
- I/O redirection
- Functions
- Introduction (History of Perl, Purpose of Perl, Where and Why it's Used, Basic Concepts)
- Scalar Data (What Is Scalar Data?, Variables, Numbers, Strings, Scalar Operators, Scalar Variables, Scalar Operators and Functions, Output with print)
- Arrays and List Data(What is Array? Variables, Array Operators and Functions, Scalar and List Context, Variable Interpolation of Arrays)
- Hashes (What Is a Hash? Hash Variables, Literal Representation of a Hash, Hash Functions, Hash Slices)
- Control Structures (Statement Blocks, The if/unless Statement, The while/until Statement, The for Statement, The foreach Statement)
- Basic I/O (Input from STDIN, Input from the Diamond Operator, Output to STDOUT)
- Functions (Defining a User Function, Invoking a User Function, Return Values, Arguments, Private Variables in Functions, File-Level my( ) Variables)
- Miscellaneous Control Structures (The last Statement, The next Statement, The redo Statement, Labeled Blocks, Expression Modifiers, && and || as Control Structures)
- Filehandles and File Tests (What Is a Filehandle? Opening and Closing a Filehandle, A Slight Diversion: die, Using Filehandles)
- Directory Access (Moving Around the Directory Tree, Globbing, Directory Handles, Opening and Closing a Directory Handle, Reading a Directory Handle)
- File and Directory Manipulation (Removing a File, Renaming a File, Making and Removing Directories, Modifying Permissions, Modifying Ownership)
- Other Data Transformation (Finding a Substring, Extracting and Replacing a Substring, Formatting Data with sprintf( ), Advanced Sorting)
- Regular Expressions (Concepts About Regular Expressions, Simple Uses of Regular Expressions, Patterns, More on the Matching Operator, Substitutions, The split and join Functions)
- Using Modules (What is a module, Overview of most common modules, Module syntaxes)
- CGI Programming(The CGI.pm Module, Your CGI Program in Context, Simplest CGI Program, Passing Parameters via CGI, Less Typing, Form Generation, Other Form Elements, Troubleshooting CGI Programs)
- Data References and Anonymous Storage (Referring to Existing Variables, Using References, Nested Data Structures, Querying a Reference, Symbolic References)
- Multi-dementional hashes and hash arrays (Multi-dementional array, Multi-dementional hash, Dereferencing, Usage)
- Database Implementation on example of mySQL (Overview of Databases, Overview of SQL, DBI Module, Embedding SQL statements in Perl)
(5 sessions: 20 hours)
Students will learn about different web servers and how to install and configure Apache web server, which is most popular and one of the most complicated ones. The course covers areas like Browser-Server communications, common error messages, security, and CGI (Common Gate Interface) environment with program examples. Students will be able to see how server can generate HTML content on the fly from basic calculations to complex database queries.
- Overview of WEB client-server architecture: Client web browser (MSIE, NN) - protocols (HTTP, HTTPS, FTP, NEWS, MAILTO, TELNET, etc.), URL components; Server - web servers (Apache, IIS, Netscape, PWS); Application servers and database conectivity; Browser - Server communication (HTTP). Request/response header/body, web server status mesages (200, 404, 302, 500, etc.)
- Installation of PWS - Personal Web Server. Basics functions and limitations
- Installation of Apache Web Server. Installation (Download, resources); Minimal required configuration. httpd.conf (server name/ip, port, components of this config file); basic functionality (directives, virtual hosts, logs); Web security overview (SSL, HTTPS)
- CGI. Environment (variables, languages); Program examples (C, PERL)
- Other Server Technologies. Application Servers (Cold Fusion, JSP, ASP); Use of Java on the WEB (Applets, Servlets)
- Databases and the WEB. Program examples
(10 sessions: 40 hours)
The class will teach you how to develop programs and testing tools in C++ language using MFC for Unit, Performance, Integration and System Testing.
- Unit Testing We're going to write some code that will test our real code. Of course, test code can be written from the ground up, but you'll see that some infrastructure is necessary. The code written to test something is called a "test case" or simply "test." Since we are in the object-oriented world, it's better to put tests into special test case classes. CppUnit provides a base Test Case class, along with other helper classes to run tests and collect and report test results. Test case classes form a manageable hierarchy. Individual tests can be composed into bunches called "test suites" and easily run as often as necessary.
- Performance Testing Performance testing is somewhat less rigid in its documentation requirements than the other types of testing. It is concerned with the responsiveness of the system, which in turn depends on the efficiency of either the underlying code or the environment in which the system is running. Profiling a code is an obvious step to take where performance is an issue, particularly for processor-intensive operations. It can point out where the most time is being consumed in a piece of code, which in turn will show you the most crucial piece of code to try to optimize.
- Integration Testing Integration testing is the next level up. It is concerned with confirming that no problems arise out of combining unit components into more complex processes. For example, two discrete functions might appear to test successfully in isolation, but if function B is fed the output of function A as one of its parameters, it might not perform as expected. A possible cause might be incorrect or insufficient data validation. Using the previous example of the calculation of the single net salary figure, the actual system might implement a menu or command button option to calculate the salaries for all employees and produce a report of the results. It is this entire routine that would qualify as an integration test. As with unit testing, it is important to write test plans that will execute along all conceivable paths between the units. Integration testing, by its nature, will probably be performed by a dedicated tester except for small projects.
- System Testing System testing is concerned with the full build of an application (or application suite). At this level, the emphasis is less on bug hunting per se and more on checking that the various parts of the system interact with each other correctly. The level of testing that would be conducted at this phase would be more system wide-for example, correct initialization from the Registry, performance, unexpected termination of resources (for example, database connections being terminated when other parts of the system still expect them to be there), logon failures, error recovery and centralized error handling (if appropriate).
(10 sessions: 40 hours)
- Introduction.Object oriented programming (Classes, Namespaces, Instance of class objects); Members of classes (Access to members, Function overloading, Operator overloading, References, pointers and objects, Static members); Inheritance (Single, Multiple, Virtual); Virtual functions (Pure virtual function, Virtual function table, Virtual function overriding); Exception handling (Exception catching, User exception throwing); Templates (Advantages and disadvantages); STL/Standard Template Library (Containers, Iterators, Algorithms, Allocators)
- Examples of C++ codes. Multithreaded programming (Processes and threads, Memory sharing, Threads and stacks, Synchronization objects); COM/DCOM programming (COM technologies, Virtual table and IUnknown interface, DLL, application, service as COM servers, Marshaling, ATL, using COM objects in ASP, Visual Basic and so on); Socket programming (TCP/IP connection, UDP connection, Socket client, Socket server); Client/Server technologies (Two layer Client/Server - thick client, Three layer Client/Application Server/Database Server - thin client, Internet client - zero client, Native database access, Custom database access); Socket programming (TCP/IP connection, UDP connection, Socket client, Socket server); Memory allocation for systems with high performance (New/delete operators and threads, Custom allocators, Multithreaded allocator manager); Microsoft Visual Studio (Powerful programming environment, Profiling, MFC (Microsoft Foundation Classes))
- C++ as a powerful tool for testing. Module testing (API interface testing, COM object testing); Multithreaded testing (Performance test, Synchronization test); Memory leaks testing (Memory leaking test)
(10 sessions: 40 hours)
- Introduction to Java Programming (Applets & Applications - differences. Writing your first applet and running it on the web using different methods)
- Understanding the Object Oriented Programming concepts (What is an Object & What is a Class ?, working with objects, inheritance, encapsulation and polymorphism)
- Datatypes, Variables, Arrays and Control statements (Arrays - declaring, creating & accessing , Vector - dynamic array, demonstrating the enumeration interface, Casting with datatypes , If & Switch , Loops - For, while & do-while)
- Creating Classes and Applications in Java (Fundamentals of classes, defining & declaring classes, creating instances and methods, adding methods to a class, using parameterized methods)
- Working with Graphics, Fonts and Color (Drawing objects like lines, rectangle, etc., demonstrating how to set background and foreground color. Creating, selecting and changing fonts)
- Inheritence (Understanding and creating superclass, subclass. Constructors - default, Constructors with parameters , Using 'super' keyword to call superclass constructors)
- Simple Animation & Multithreaded Programming (What is a thread ? Creating a thread. Implementing Runnable. Usage of the sleep method)
- Images & Sounds (Creating , Loading and displaying images. The use of MediaTracker , Double Buffering technique - using images as an offscreen drawing surface, Producing Sounds using AudioClip interface - How to play, stop and continue playing sounds using different methods)
- Event Handling (Events generated by the mouse & the keyboard. Listeners - How Java listens to mouse events like mouse click & keyboard events like key press)
- GUI Components (Creating buttons, check boxes, list boxes, labels, text fields, text areas, etc. Creating frame windows, adding menu bars and menu items)
- Exception handling ( How to handle a runtime error. Creating an object representing the exception and how it is thrown and caught and processed. Using try, catch & throw)
- Input/Output (The Stream Classes - reading and writing bytes from and to a file)
(10 sessions: 40 hours)
ORACLE Application Development
|
(50 sessions: 200 hours)
This comprehensive course is a starting point for developers new to Oracle environment. It focuses on the knowledge and skills needed to develop Oracle applications effectively.
You begin with an overview of relational database concepts and basics of Oracle8i database design and operating principals. Through lectures, hands-on exercises and class projects you learn in detail how to use SQL to create and manipulate data and databases, how to code in PL/SQL and create stored procedures, functions, packages and database triggers. You get familiar with SQL*Plus, SQL*Loader as well as learn basic concepts of database administration. The course provides detailed study of Oracle Developer suite of tools including Oracle Forms, Reports, Graphics Builder, Project Builder etc. You learn how to integrate the forms, reports, menus and graphics components to create full-featured applications.
Upon successful completion of the course you will be well prepared for the role of Oracle application developer and able to pass all exams for getting Oracle Certified Professional (OCP Developer's track) certificate.
- Introduction to Oracle: Critical database concepts: overview of relational and object-relational databases, database design and normalization. SQL: data selection, restricting and sorting data, single row functions, joins, group functions, subqueries, manipulating data. Producing readable output with SQL*Plus. Creating and manipulating database objects: tables, integrity constraints, views, indexes, sequences. Basic concepts of database administration: database architecture, parameter file, controlling user access, Oracle data dictionary, Oracle optimizer, configuring Net8, database links. Using SQL*Loader to load data into tables.
- PL/SQL Programming: Introduction to application development and PL/SQL: life cycle of system development, PL/SQL program constructs, datatypes, conditional control, built-in functions, database interaction and cursors, PL/SQL tables and records. Developing PL/SQL program units: procedures, functions, packages, exception handling, debugging, using Oracle-supplied packages. Managing procedural dependencies. Developing database triggers. Advanced topics: object types, nested tables and varrays, object views,external procedures.
- Oracle Developer Suite - Part I: Introduction to Oracle Developer Rel.6i. Form Builder: main components and executables, creating basic form module, runtime environment. Forms design: working with data blocks, frames, items, creating LOVs, editors, windows and canvases. Working with triggers. Forms processing: runtime messages and alerts, validation, navigation, transaction processing. Forms programming: writing flexible code, reusing objects and code.
- Oracle Developer Suite - Part II: Introduction to Project Builder. Working with Menu modules. Advanced Forms programming: programming function keys, responding to mouse events, controlling windows, canvases and relationships, building multiple-form applications, defining data sources, working with record groups, including charts and reports in Forms, using server features in Form Builder.
- Oracle Developer Suite - Part III: Introduction to Reports Builder: executable components, designing and running reports, using Report Wizard and Query Builder. Live Previewer, report templates, report storage methods. Using Data Model to create queries, groups and columns. Enhancing layout using Layout Model, modifying layout properties. Using report parameters and Parameter Forms. Embedding charts in reports, using Graphics Builder. Developing different report styles. Advanced topics in report design: creating triggers, using built-in packages, maximizing performance, building reports for different environments.
(10 sessions: 40 hours)
- Introduction to Software Release Engineering Goals, responsibilities, overview of tools used, market requirements
- Microsoft Developer Studio Source code, binaries, compiling, linking, project files (*.mak)
- Automated build process using batch script and macro language Main principle, batch scripting, macro language, tools and utilities
- Source control tool management Main idea, responsibilities
- MS Source Safe as an example of source control tool Goal, administration of MSS
- StarTeam as an example of source control tool Server part, client part, administration
- Administration of bug-tracking system
- InstallShield Concepts, goals, writing scripts
- Release CD creation
- Management Issues Relations between management, developers, release engineer, QA team and marketing
(10 sessions: 40 hours)
Advance your career from SQA Engineer to SQA Technical Lead, Manager, or Director! Use the latest tools & techniques in industry. Taught by Greg Mandanis, the author of the best-selling "Software Project Management Kit For Dummies" book  .
- Management Issues Relations between management, developers, release engineer, QA team and marketing
- Promoting SQA Throughout Software Development Process
- Fostering Cooperation between QA, Development, & Other Teams
- Learning to Say "No!" to Poor Software Quality & Broken SQA Processes with Diplomacy
- Coordinating Meetings Effectively
- Scheduling, Assigning Resources with Microsoft Project 2000
- Estimating Project Costs with Cost Xpert Tools
- Selecting & Implementing Defect/Change Management System
- Developing People Skills for Hiring, Training, Motivating & Conducting Performance Reviews
- Communicating with both Technical & Non-Technical Employees & Customers
- Diplomatically Handling Office Politics
- Managing Daily Pressures, Change, Company Re-orgs & Downsizing
- Course includes:
Microsoft Project 2000 (trial version), Soffront TRACK and Cost Xpert (trial versions), Templates and planning tools, Software Project Management Kit (Purchase here)
The classes listed above are meant for the SQA Engineers interested in getting more marketable skills. The courses offered are not academic by design, but rather hands-on and organized on project-by-project basis.
|
|
School philosophy