trigger test on Lead (before update) {
 for(Lead lead:System.Trigger.new) {
  if (Lead.IsConverted)
  //do somethign here with converted leads
 }
}

trigger lead_onConvert on Lead (after update) {

	/*
	 * Create variables to store the lead values,
	 * new and old.  This will be used below to
	 * determine if the leads are being converted,
	 * not converted yet, or has already been
	 * converted.
	 */
	List<Lead> newLeads = trigger.new;
	Map<Id, Lead> mOldLeads = trigger.oldMap;
	Lead oldLead;
	
	/*
	 * Create sets of Ids to store the records
	 * associated with the converted leads
	 */
	Set<Id> convertedAccountIds = new Set<Id>();
	Set<Id> convertedContactIds = new Set<Id>();
	Set<Id> convertedOpportunityIds = new Set<Id>();

	/*
	 * Loop through the leads submitted through this
	 * trigger.  Populate the appropriate sets of Ids
	 * for each lead with populated values.
	 */
	for (Lead l : newLeads) {
		
		if (l.convertedAccountId != null) {
			convertedAccountIds.add(l.convertedAccountId);
		}
		
		if (l.convertedContactId != null) {
			convertedContactIds.add(l.convertedContactId);
		}
		
		if (l.convertedOpportunityId != null) {
			convertedOpportunityIds.add(l.convertedOpportunityId);
		}
	}
	
	/*
	 * Extract the records associated with each set of
	 * Ids populated above.  Once the data has been extracted
	 * store it in a map so it can efficiently be referenced
	 * in the main loop below.
	 */
	List<Account> accounts =
		[SELECT Id, Name
		 FROM Account
		 WHERE Id IN : convertedAccountIds];
		 
	Map<Id, Account> mAccounts = new Map<Id, Account>(accounts);
	
	List<Contact> contacts =
		[SELECT Id, Name
		 FROM Contact
		 WHERE Id IN : convertedContactIds];
		 
	Map<Id, Contact> mContacts = new Map<Id, Contact>(contacts);
	
	List<Opportunity> opportunities =
		[SELECT Id, Name
		 FROM Opportunity
		 WHERE Id IN : convertedOpportunityIds];
		 
	Map<Id, Opportunity> mOpportunities = new Map<Id, Opportunity>(opportunities);

	/*
	 * Create lists of records to be updated in bulk at
	 * the end of this trigger.  We use a separate list
	 * to ensure we aren't updating records that are
	 * not affected by this trigger.
	 */
	List<Account> updateAccounts = new List<Account>();
	List<Contact> updateContacts = new List<Contact>();
	List<Opportunity> updateOpportunities = new List<Opportunity>();

	/*
	 * MAIN LOOP
	 *
	 * Loop through all leads submitted through this trigger.
	 * If this trigger was executed because of a conversion
	 * we will populate the related records.
	 */
	for (Lead newLead : newLeads) {
		
		// Get a reference to the old values associated
		// with this lead.
		oldLead = mOldLeads.get(newLead.Id);
		
		// Determine if the lead was converted or not.
		// If the previous status was not converted and
		// the current status is converted, then this
		// trigger executed because of a conversion.
		if (!oldLead.IsConverted && newLead.isConverted) {
		
			// ** CONVERSION FOUND **
			
			Account account = mAccounts.get(newLead.convertedAccountId);
			// Make appropriate updates here.
			updateAccounts.add(account);
			
			Contact contact = mContacts.get(newLead.convertedContactId);
			// Make appropriate updates here.
			updateContacts.add(contact);
			
			Opportunity opportunity = mOpportunities.get(newLead.convertedOpportunityId);
			// Make appropriate updates here.
			updateOpportunities.add(opportunity);
			
		}
	}
	
	/*
	 * Update the records for any update list
	 * populated with records.
	 */ 
	if (updateAccounts.size() > 0) {
		update updateAccounts;
	}
	
	if (updateContacts.size() > 0) {
		update updateContacts;
	}
	
	if (updateOpportunities.size() > 0) {
		update updateOpportunities;
	}
}