Azhar's profileSoftware Testing an Art ...PhotosBlogListsMore Tools Help

Blog


    March 14

    IBM Page Detailer

    Why IBM Page Detailer?

    There are five major elements that influence an end user's experience while accessing a Web site:

    • The content of the page (information).

    • The presentation of the content (look and feel).

    • The efficiency of presentation (size).

    • The organization of content (packaging).

    • The administration of the Web site (delivery).

    Although IBM Page Detailer does not address the first two elements, content and presentation, it can provide information useful in improving the last three: efficiency, organization, and administration.

    Developers agree there is no absolutely "correct" way to set up a Web site. Multiple design and operational tradeoffs exist in setting up even small sites, but IBM Page Detailer can be used to quantify the impact of tradeoffs by providing performance data about the site both before and after changes. IBM Page Detailer provides information well suited to the analysis of size, packaging, and delivery elements of the end user experience. Routine use of IBM Page Detailer to analyze Web pages can also help identify new opportunities for improvement as designs are tested and moved into production.

    IBM Page Detailer can also be used to help confirm Web page design standards and practices for an organization. In a test environment, proposed design standards and practices can be prototyped and analyzed with IBM Page Detailer. IBM Page Detailer can give your team insight as to what impact your new design choices will have on an end user.

    The IBM Page Detailer tool is designed to explain some of the mysteries about how Web pages are delivered to Web browsers.

    IBM Page Detailer can help Web developers, designers, site operators, and IT specialists to isolate problems and improve performance and user satisfaction. It does this by revealing details about the timing, size, and identity of each item in a page.The details revealed can be used to identify areas where performance could be improved to enhance the end user experience

    Starting IBM Page Detailer

    IBM Page Detailer attaches to the workstation TCP/IP socket stack and monitors all of the HTTP/HTTPS protocol based communications between your Web browser and the network. IBM Page Detailer then displays web activities in a series of color-coded bars.

    To start IBM Page Detailer, double-click the IBM Page Detailer Basic icon:  

    IBM Page Detailer Basic

    IBM Page Detailer Basic

    This will start IBM Page Detailer.

    Note:  If the icon is not on your desktop, you can find it in the IBM Page Detailer folder accessible via the Start Programs menu.

    To monitor communications between your Web browser and your network, just start the browser (Internet Explorer or Netscape). Shortly after the first page has loaded into the browser, the IBM Page Detailer chart will be displayed.

    Web Communications

    The time it takes to download a page is the result of many factors and the interactions among them. Page designers who understand these factors can best optimize page download time. A significant factor is how basic and secured Web site communications work. ......

     

    IBM Page Detailer

    March 12

    watir an Open Source Automated Testing Tool

    Automated testing that doesn’t hurt

    Watir is a simple open-source library for automating web browsers. It allows you to write tests that are easy to read and easy to maintain. It is optimized for simplicity and flexibility.

    Watir drives browsers the same way people do. It clicks links, fills in forms, presses buttons. Watir also checks results, such as whether expected text appears on the page.

    Watir is a Ruby library that works with Internet Explorer on Windows. Watir is currently being ported to support Firefox and Safari.

    Like other programming languages, Ruby gives you the power to connect to databases, read data files, export XML and structure your code into reusable libraries. Unlike other programing languages, Ruby is concise and often a joy to read.

    Watir stands for “Web Application Testing in Ruby”. It is pronounced water.....

    for details  check http://wtr.rubyforge.org/

    I run watir and given below are my  observations..

    Good Points.....

    1. Open source and don't have to spend penny..

    2. Ruby based script and fast exection.

    Drawbacks.....

    1. No recording option in watir like i do in QTP or Robot

    2. Coding is hard to learn and implement.

    3. Very little help avilable.

    March 05

    New Functions to be Test & Implement in Postgis

    Functions to be Tested & implemented in Postgis

    version()
    postgis_lib_version()
    postgis_lib_build_date()
    postgis_lib_build_date()
    postgis_scripts_installed()
    postgis_scripts_released()
    postgis_geos_version()
    postgis_proj_version()
    postgis_uses_stats()
    postgis_full_version()
    length2d
    length3d
    length2d
    AsEWKT
    distance
    AddBBOX
    DropBBOX
    Force_collection(geometry)
    Force_2d(geometry)
    Force_3dz(geometry)
    Force_3d(geometry)
    Force_3dm(geometry)
    Force_3dm(geometry)
    Force_4d(geometry)
    box2d(geometry)
    box3d(geometry)
    extent(geometry)
    zmflag(geometry)
    HasBBOX(geometry)
    ndims(geometry)
    nrings(geometry)
    npoints(geometry)
    isvalid(geometry)
    expand(geometry, 1000.23)
    mem_size(geometry)
    mem_size(geometry)
    Accum(geometry)
    Accum(geometry)
    GeometryType(geometry)
    StartPoint(geometry)
    AsBinary(geometry)
    SRID(geometry)
    Dimension(geometry)
    Envelope(geometry)
    IsEmpty(geometry)
    IsSimple(geometry)
    IsClosed(geometry)
    IsRing(geometry)
    NumGeometries(geometry)
    GeometryN(geometry, 5)
    ExteriorRing(geometry)
    NumInteriorRings(geometry)
    InteriorRingN(geometry,2)
    EndPoint(geometry)
    GeomUnion(geometry,geometry)
    Difference(geometry,geometry)
    SymDifference(geometry,geometry)
    GeomUnion(geometry,geometry)
    Collect(geometry,geometry)
    Dump(geometry)

    February 28

    Installation of PostGIS

    Installation of PostGIS
    *************************************

    2.1. Requirements

    PostGIS has the following requirements for building and usage:

    • A complete installation of PostgreSQL (including server headers). PostgreSQL is available from http://www.postgresql.org. Version 7.2 or higher is required.

    • GNU C compiler (gcc). Some other ANSI C compilers can be used to compile PostGIS, but we find far fewer problems when compiling with gcc.

    • GNU Make (gmake or make). For many systems, GNU make is the default version of make. Check the version by invoking make -v. Other versions of make may not process the PostGIS Makefile properly.

    • (Recommended) Proj4 reprojection library. The Proj4 library is used to provide coordinate reprojection support within PostGIS. Proj4 is available for download from http://www.remotesensing.org/proj.

    • (Recommended) GEOS geometry library. The GEOS library is used to provide geometry tests (ST_Touches(), ST_Contains(), ST_Intersects()) and operations (ST_Buffer(), ST_Union(), ST_Difference()) within PostGIS. GEOS is available for download from http://geos.refractions.net.

    2.2. PostGIS

    The PostGIS module is a extension to the PostgreSQL backend server. As such, PostGIS 1.3.3SVN requires full PostgreSQL server headers access in order to compile. The PostgreSQL source code is available at http://www.postgresql.org.

    PostGIS 1.3.3SVN can be built against PostgreSQL versions 7.2.0 or higher. Earlier versions of PostgreSQL are not supported.

    1. Before you can compile the PostGIS server modules, you must compile and install the PostgreSQL package.

      Note

      If you plan to use GEOS functionality you might need to explicitly link PostgreSQL against the standard C++ library:

      LDFLAGS=-lstdc++ ./configure [YOUR OPTIONS HERE]

      This is a workaround for bogus C++ exceptions interaction with older development tools. If you experience weird problems (backend unexpectedly closed or similar things) try this trick. This will require recompiling your PostgreSQL from scratch, of course.

    2. Retrieve the PostGIS source archive from http://postgis.refractions.net/postgis-1.3.3SVN.tar.gz. Uncompress and untar the archive.

      # gzip -d -c postgis-1.3.3SVN.tar.gz | tar xvf -
    3. Enter the postgis-1.3.3SVN directory, and run:

      # ./configure
      • If you want support for coordinate reprojection, you must have the Proj4 library installed. If ./configure didn't find it, try using --with-proj=PATH switch specify a specific Proj4 installation directory.

      • If you want to use GEOS functionality, you must have the GEOS library installed. If ./configure didn't find it, try using --with-geos=PATH to specify the full path to the geos-config program full path.

    4. Run the compile and install commands.

      # make # make install

      All files are installed using information provided by pg_config

      • Libraries are installed [pkglibdir]/lib/contrib.

      • Important support files such as lwpostgis.sql are installed in [prefix]/share/contrib.

      • Loader and dumper binaries are installed in [bindir]/.

    5. PostGIS requires the PL/pgSQL procedural language extension. Before loading the lwpostgis.sql file, you must first enable PL/pgSQL. You should use the createlang command. The PostgreSQL Programmer's Guide has the details if you want to this manually for some reason.

      # createlang plpgsql [yourdatabase]
    6. Now load the PostGIS object and function definitions into your database by loading the lwpostgis.sql definitions file.

      # psql -d [yourdatabase] -f lwpostgis.sql

      The PostGIS server extensions are now loaded and ready to use.

    7. For a complete set of EPSG coordinate system definition identifiers, you can also load the spatial_ref_sys.sql definitions file and populate the SPATIAL_REF_SYS table.

      # psql -d [yourdatabase] -f spatial_ref_sys.sql

    2.2.1. Creating PostGIS spatially-enabled databases from an in-built template

    Some packaged distributions of PostGIS (in particular the Win32 installers for PostGIS >= 1.1.5) load the PostGIS functions into a template database called template_postgis. If the template_postgis database exists in your PostgreSQL installation then it is possible for users and/or applications to create spatially-enabled databases using a single command. Note that in both cases, the database user must have been granted the privilege to create new databases.

    From the shell:

    # createdb -T template_postgis my_spatial_db

    From SQL:

    postgres=# CREATE DATABASE my_spatial_db TEMPLATE=template_postgis

    2.2.2. Upgrading

    Upgrading existing spatial databases can be tricky as it requires replacement or introduction of new PostGIS object definitions.

    Unfortunately not all definitions can be easily replaced in a live database, so sometimes your best bet is a dump/reload process.

    PostGIS provides a SOFT UPGRADE procedure for minor or bugfix releases, and an HARD UPGRADE procedure for major releases.

    Before attempting to upgrade postgis, it is always worth to backup your data. If you use the -Fc flag to pg_dump you will always be able to restore the dump with an HARD UPGRADE.

    2.2.2.1. Soft upgrade

    Soft upgrade consists of sourcing the lwpostgis_upgrade.sql script in your spatial database:

    $ psql -f lwpostgis_upgrade.sql -d your_spatial_database

    If a soft upgrade is not possible the script will abort and you will be warned about HARD UPGRADE being required, so do not hesitate to try a soft upgrade first.

    Note

    If you can't find the lwpostgis_upgrade.sql file you are probably using a version prior to 1.1 and must generate that file by yourself. This is done with the following command:

    $ utils/postgis_proc_upgrade.pl lwpostgis.sql > lwpostgis_upgrade.sql

    2.2.2.2. Hard upgrade

    By HARD UPGRADE we intend full dump/reload of postgis-enabled databases. You need an HARD UPGRADE when postgis objects' internal storage changes or when SOFT UPGRADE is not possible. The Release Notes appendix reports for each version whether you need a dump/reload (HARD UPGRADE) to upgrade.

    PostGIS provides an utility script to restore a dump produced with the pg_dump -Fc command. It is experimental so redirecting its output to a file will help in case of problems. The procedure is as follow:

    Create a "custom-format" dump of the database you want to upgrade (let's call it "olddb")

    $ pg_dump -Fc olddb > olddb.dump

    Restore the dump contextually upgrading postgis into a new database. The new database doesn't have to exist. postgis_restore accepts createdb parameters after the dump file name, and that can for instance be used if you are using a non-default character encoding for your database. Let's call it "newdb", with UNICODE as the character encoding:

    $ sh utils/postgis_restore.pl lwpostgis.sql newdb olddb.dump -E=UNICODE > restore.log

    Check that all restored dump objects really had to be restored from dump and do not conflict with the ones defined in lwpostgis.sql

    $ grep ^KEEPING restore.log | less

    If upgrading from PostgreSQL < 8.0 to >= 8.0 you might want to drop the attrelid, varattnum and stats columns in the geometry_columns table, which are no-more needed. Keeping them won't hurt. DROPPING THEM WHEN REALLY NEEDED WILL DO HURT !

    $ psql newdb -c "ALTER TABLE geometry_columns DROP attrelid" 
    $ psql newdb -c "ALTER TABLE geometry_columns DROP varattnum" 
    $ psql newdb -c "ALTER TABLE geometry_columns DROP stats"

    spatial_ref_sys table is restore from the dump, to ensure your custom additions are kept, but the distributed one might contain modification so you should backup your entries, drop the table and source the new one. If you did make additions we assume you know how to backup them before upgrading the table. Replace of it with the new one is done like this:

    $ psql newdb 
    newdb=> drop spatial_ref_sys; 
    DROP 
    newdb=> \i spatial_ref_sys.sql

    2.2.3. Common Problems

    There are several things to check when your installation or upgrade doesn't go as you expected.

    1. It is easiest if you untar the PostGIS distribution into the contrib directory under the PostgreSQL source tree. However, if this is not possible for some reason, you can set the PGSQL_SRC environment variable to the path to the PostgreSQL source directory. This will allow you to compile PostGIS, but the make install may not work, so be prepared to copy the PostGIS library and executable files to the appropriate locations yourself.

    2. Check that you you have installed PostgreSQL 7.2 or newer, and that you are compiling against the same version of the PostgreSQL source as the version of PostgreSQL that is running. Mix-ups can occur when your (Linux) distribution has already installed PostgreSQL, or you have otherwise installed PostgreSQL before and forgotten about it. PostGIS will only work with PostgreSQL 7.2 or newer, and strange, unexpected error messages will result if you use an older version. To check the version of PostgreSQL which is running, connect to the database using psql and run this query:

      SELECT version();

      If you are running an RPM based distribution, you can check for the existence of pre-installed packages using the rpm command as follows: rpm -qa | grep postgresql

    Also check that you have made any necessary changes to the top of the Makefile.config. This includes:

    1. If you want to be able to do coordinate reprojections, you must install the Proj4 library on your system, set the USE_PROJ variable to 1 and the PROJ_DIR to your installation prefix in the Makefile.config.

    2. If you want to be able to use GEOS functions you must install the GEOS library on your system, and set the USE_GEOS to 1 and the GEOS_DIR to your installation prefix in the Makefile.config

    2.3. JDBC

    The JDBC extensions provide Java objects corresponding to the internal PostGIS types. These objects can be used to write Java clients which query the PostGIS database and draw or do calculations on the GIS data in PostGIS.

    1. Enter the jdbc sub-directory of the PostGIS distribution.

    2. Edit the Makefile to provide the correct paths of your java compiler (JAVAC) and interpreter (JAVA).

    3. Run the make command. Copy the postgis.jar file to wherever you keep your java libraries.

    2.4. Loader/Dumper

    The data loader and dumper are built and installed automatically as part of the PostGIS build. To build and install them manually:

    # cd postgis-1.3.3SVN/loader 
    # make 
    # make install

    The loader is called shp2pgsql and converts ESRI Shape files into SQL suitable for loading in PostGIS/PostgreSQL. The dumper is called pgsql2shp and converts PostGIS tables (or queries) into ESRI Shape files. For more verbose documentation, see the online help, and the manual pages.

    August 29

    How to Test Postgis on Windows

    Test Description Input Expected Output
             
    PostGis(Windows)    
    Copy Files  $EDB_HOME/spatial/lib/liblwgeom.dll     $EDB_HOME/dbserver/lib File Exist and is copied to destination
    Copy Files  $EDB_HOME/spatial/lib/libgeos-2.dll           $EDB_HOME/dbserver/bin File Exist and is copied to destination
    Copy Files  $EDB_HOME/spatial/lib/libgeos_C-1.dll         $EDB_HOME/dbserver/bin File Exist and is copied to destination
    Copy Files  $EDB_HOME/spatial/share/lwpostgis.sql   $EDB_HOME/dbserver/share/contrib File Exist and is copied to destination
    Copy Files  $EDB_HOME/spatial/share/spatial_ref_sys.sql  $EDB_HOME/dbserver/share/contrib File Exist and is copied to destination
    Copy Files  $EDB_HOME/spatial/share/lwpostgis_upgrade.sql $EDB_HOME/dbserver/share/contrib File Exist and is copied to destination
    Execute the scriptc:\plugins_test_scripts\postgis_arts_win.sql and save the output in a new file  C:\EnterpriseDB\8.2\dbserver\bin & edb-psql.exe -U enterprisedb -d edb -f c:\plugins_test_scripts\postgis_arts_win.sql > C:\Results\postgis_arts_Result 2>&1 Scipt will be executed and output is saved in new file
    Compare the result with the previous file use WinMerge Software C:\Program Files\WinMerge & WinMerge.exe C:\plugins_test_scripts\plugins_test_scripts\postgis_arts_win.sql.053007 C:\Results\postgis_arts_Result Compare with the previous installer file
    May 04

    Developing Software Using UCM

    UCM structures the efforts of your software development team into a defined, repeatable process. This section provides an overview of the workflow for developers in UCM. Joining a Project A developer starts work by joining a UCM project. When you join a project, you create your private work area and populate it with the contents of the project's baselines. Shared and Private Work Areas A work area consists of a view and a stream. A view is a directory tree that shows a single version of each file in your project. A stream is a ClearCase object that maintains a list of activities and baselines and determines which versions of elements appear in your view. A project contains one integration stream, which records the project's baselines and enables access to shared versions of the project's elements. The integration stream and a corresponding integration view represent the project's shared work area. Each developer on the project has a private work area, which consists of a development stream and a corresponding development view. The development stream maintains a list of the developer's activities and determines which versions of elements appear in the developer's view. In the basic UCM process, the integration stream is the project's only shared work area. The project manager or lead developer may want to create additional shared work areas for developers who are working together on specific parts of the project. You can accomplish this by creating a hierarchy of development streams. For example, you can create a development stream and designate it as the shared work area for developers working on a particular feature. Developers then create their own development streams and views under the development stream for this feature. The developers deliver work to and rebase their streams to recommended baselines in the feature's development stream. Working on Activities All work on your development stream takes place as part of a UCM activity. An activity is an object that tracks the work required to complete a development task, such as fixing a bug. Finding or Creating an Activity for Your Work If your project uses Rational ClearQuest, you can use a to-do list in ClearQuest to access activities that you, your project manager, or other team members assign to you. You can also create and use activities when you check out files and directories. Modifying and Testing Source Files To modify source files, go into your development view and check them out. When you want to keep a record of a file's current state, check it in. Any work you check in from your development view is not available to other team members until you deliver it. Make sure the changes in your development view build and function properly before you deliver them. Delivering Activities When you are ready to make one or more of your activities available to the project team, you deliver them from your development stream to either the project's integration stream or the feature-specific development stream. Starting the Deliver Operation When you start a deliver operation, ClearCase integrates the changes from your development work area to the integration work area or feature-specific development stream. At this point, the files are checked out to your integration view. Testing Your Work You should build and test your work against the latest project work. To do this, use your integration view to access both the versions you delivered from your development work area and the latest versions delivered by the other developers working on the project. Completing the Deliver Operation When you are satisfied that your changes are compatible with the latest work for the project, you complete the deliver operation. (If you are not satisfied, you can cancel it.) The deliver operation checks in the files that were integrated from the development work area to the integration work area or feature-specific development stream. Delivering with MultiSite If your project uses Rational ClearCase MultiSite to share source data with developers in other geographical locations, you may use a different method for delivering activities. If a different site is responsible for controlling your project's source data, your organizational policy may require that you notify the integrator or project manager at that site when you deliver changes. That person merges your activities to the integration stream and tests your work. Rebasing Your Work Area Periodically, your project manager groups delivered activities into baselines, which are versions of each component in the project. Some of these baselines constitute a stable and significant source configuration; your project manager will recommend that you rebase your development work area to the recommended configuration. Starting the Rebase Operation When you start the rebase operation, ClearCase integrates the versions specified by the recommended baseline in either the project's integration stream or the feature-specific development stream into your development work area. At this point, the files are checked out to your development view. Testing Your Development Work Area You should test your work against the latest project work. To do this, use your development view to access both the versions you integrated from the integration stream or feature-specific development stream and the latest (undelivered) versions in your development work area. Completing the Rebase Operation When you are satisfied that the recommended baseline is compatible with the work you have done in your development stream, you complete the rebase operation. (If you are not satisfied, you can cancel it.) The rebase operation checks in the files that were integrated from the integration stream or feature-specific development stream to the development work area.