Subversion Repositories DevTools

#include "CopyIteration.h"

#include "IHash.h"

			IterationCopyButton->Enabled = true;

			IterationCopyButton->Enabled = false;

	}

	{

		IterationCopyButton->Enabled = false;

	}

void __fastcall TMainForm::IterationCopyButtonClick(TObject *Sender)

{

	if ( !m_currentproject.IsEmpty() && m_currentiteration )

	{

		CopyIterationForm->ShowForm( m_currentproject, m_currentiteration );

	}

}

//---------------------------------------------------------------------------

void __fastcall TMainForm::generateTransaction( std::vector< int > & scenarios )

{

	if ( GenerationPropertiesForm->ShowModal() == mrOk )

	{

		const bool				generateHeaders	= GenerationPropertiesForm->GenerateHeadersCheckBox->Checked;

		const std::string		folder			= GenerationPropertiesForm->GenerationFolderDirectoryEdit->Text.c_str();

		const std::string		batchPrefix		= GenerationPropertiesForm->DrainFilePrefixEdit->Text.c_str();

		const std::string		batchSuffix		= GenerationPropertiesForm->DrainFileSuffixEdit->Text.c_str();

		const bool				buildManifest	= GenerationPropertiesForm->BuildManifestCheckBox->Checked;

		const std::string		manifestPrefix	= GenerationPropertiesForm->ManifestPrefixEdit->Text.c_str();

		const std::string		manifestSuffix	= GenerationPropertiesForm->ManifestSuffixEdit->Text.c_str();

		const std::string		securityServer	= GenerationPropertiesForm->SecurityServerPipeEdit->Text.c_str();

		const unsigned short	keyNumber		= GenerationPropertiesForm->KeyNumberEdit->Text.ToInt();

		const unsigned short	keyVersion		= -2;

		const std::string		pathmapTarget	= GenerationPropertiesForm->PathmapTargetEdit->Text.c_str();

		const int				macAlgorithm	= GenerationPropertiesForm->MacAlgorithmComboBox->ItemIndex;

		/**

			Create a transaction stream into our generation folder, and generate

			the transactions into it.  We need to know whether we have to prepend

			header (i.e., whether it is a .xdr which has a header, or a .devud which

			doesn't).

		 */

		const TCursor				Save_Cursor					= Screen->Cursor;

		bool						transactionOpen				= false;

		ICryptographicServerProxy *	cryptographicServerProxy	= 0;

		IMessageDigest *			messageDigest				= 0;

		IHash *						hash						= 0;

		try

		{

			if ( m_securityWrapperFactory )

			{

				cryptographicServerProxy = m_securityWrapperFactory

					->createCryptographicServerProxy( securityServer.c_str() );

				if ( cryptographicServerProxy )

				{

					if ( cryptographicServerProxy->getModuleCount() )

					{

						/**

						 *	We don't know which module will be used to compute the

						 *	MAC (security doesn't tell us), so until they do we

						 *	assume its the first module.

						 */

						const unsigned int serialNumber =

							cryptographicServerProxy->getSerialNumber( 0 );

						/**

							We now need to turn the 4-byte serial number into an

							8-byte diversifier.  Apparently, we must do this by

							writing the serial number into the lower 4-bytes in big

							endian.  An API is being added to crypto to do this:

							until it is there we need to do it ourselves.

						 */

						unsigned char buffer[ 8 ];

						buffer[ 0 ] = 0;

						buffer[ 1 ] = 0;

						buffer[ 2 ] = 0;

						buffer[ 3 ] = 0;

						buffer[ 4 ] = ( serialNumber >> 24 ) & 0xFF;

						buffer[ 5 ] = ( serialNumber >> 16 ) & 0xFF;

						buffer[ 6 ] = ( serialNumber >>  8 ) & 0xFF;

						buffer[ 7 ] = ( serialNumber       ) & 0xFF;

						messageDigest = m_securityWrapperFactory

							->createMessageDigest(

								*cryptographicServerProxy,

								keyNumber,

								keyVersion,

								buffer,

								sizeof( buffer ) );

						/**

						 *	If we need to compute the MAC by computing the MAC

						 *	of the SHA-1 hash, then we create the hash object

						 *	here.

						 */

						if ( macAlgorithm == 1 )

						{

							hash = m_securityWrapperFactory->createHash();

						}

					}

					else

					{

						MWARNING( "Cryptographic server has no modules." );

					}

				}

			}

			Screen->Cursor = crHourGlass;

			Data_Module->IntegrationDBConnection->BeginTrans();

			transactionOpen = true;

			TransactionStream stream(

				folder,

				batchPrefix,

				batchSuffix,

				buildManifest,

				manifestPrefix,

				manifestSuffix,

				pathmapTarget );

			Iteration iteration(

				m_currentproject.c_str(),

				m_currentiteration,

				*XMLSchema->GetSchemaWrapperFactory(),

				*XMLSchema->GetSchema(),

				m_schema_handle );

			DefinedVariableTable	definedVariableTable;

			SequenceCollection		sequences;

			TimeEstimate			timeEstimate( *MainStatusBar->Panels->Items[ 0 ] );

			EvaluationContext		context(

				definedVariableTable,

				sequences,

				*m_progressBar,

				messageDigest,

				hash,

				cryptographicServerProxy,

				timeEstimate );

			buildExecutionSchedule(

				iteration,

				TestCaseQuery->FieldByName( "TESTCASE_ID" )->AsString.c_str() );

			loadLegacyVariables(

				definedVariableTable,

				m_currentproject.c_str(),

				iteration );

			readSequences(

				sequences,

				m_currentproject.c_str(),

				m_currentiteration );

			try

			{

				int		count		= 0;

				bool	generated	= false;

				if ( scenarios.empty() )

				{

					count = iteration.getTransactionCount();

					m_progressBar->open( count );

					timeEstimate.start( count );

					generated = iteration.generate(

						stream,

						generateHeaders,

						context );

				}

				else

				{

					std::vector< int >::const_iterator where = scenarios.begin();

					for ( where = scenarios.begin();

						  where != scenarios.end();

						  ++where )

					{

						count += iteration.

							findTestScenario( *where ).getTransactionCount();

					}

					m_progressBar->open( count );

					timeEstimate.start( count );

					for ( where = scenarios.begin();

						  where != scenarios.end();

						  ++where )

					{

						iteration.findTestScenario( *where ).generate(

							stream,

							generateHeaders,

							context );

					}

				}

				if ( generated )

				{

					writeSequences(

						sequences,

						m_currentproject.c_str(),

						m_currentiteration );

					Data_Module->IntegrationDBConnection->CommitTrans();

					transactionOpen = false;

				}

			}

			__finally

			{

				timeEstimate.stop();

				m_progressBar->close();

			}

		}

		__finally

		{

			if ( hash )

			{

				m_securityWrapperFactory->destroyHash( *hash );

				hash = 0;

			}

			if ( messageDigest )

			{

				m_securityWrapperFactory

					->destroyMessageDigest( *messageDigest );

				messageDigest = 0;

			}

			if ( cryptographicServerProxy )

			{

				m_securityWrapperFactory

					->destroyCryptographicServerProxy( *cryptographicServerProxy );

				cryptographicServerProxy = 0;

			}

			if ( transactionOpen )

			{

				Data_Module->IntegrationDBConnection->RollbackTrans();

			}

			Screen->Cursor = Save_Cursor;

		}

	}

}

//---------------------------------------------------------------------------

void __fastcall TMainForm::GenerateActionExecute(TObject *Sender)

{

	TTreeNode *			currentNode = 0;

	std::vector< int >	scenarios;

	for ( unsigned selection=0;

		  selection<TestCaseTreeView->SelectionCount;

		  selection++ )

	{

		currentNode = TestCaseTreeView->Selections[ selection ];

		if ( currentNode )

		{

			scenarios.push_back( reinterpret_cast< int >( currentNode->Data ) );

		}

	}

	generateTransaction( scenarios );

}

//---------------------------------------------------------------------------