// Copyright (C) 2005 - 2006 Symbian Ltd. All Rights Reserved


<action>
	<actionname>Element test case 1 with explicit kdf, salt len and iterations, ECipherRC2_CBC_128_16</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_128_16</cipher>
		<kdf>PKCS#5</kdf>
		<salt_len_bytes>16</salt_len_bytes>
		<iter_count>1000</iter_count>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Element test case 1, ECipherRC2_CBC_128_16</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_128_16</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Element test case 2, ECipherRC2_CBC_128_16</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_128_16</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Element test case 3, ECipherRC2_CBC_128_16</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_128_16</cipher>
		<element>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 1, ECipherRC2_CBC_128_16</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_128_16</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 1, explicit kdf, salt len, iter count, ECipherRC2_CBC_128_16</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_128_16</cipher>
		<kdf>PKCS#5</kdf>
		<salt_len_bytes>16</salt_len_bytes>
		<iter_count>1000</iter_count>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 2 -- 1 byte input, ECipherRC2_CBC_128_16</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_128_16</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>B</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 3 -- 8 byte input, ECipherRC2_CBC_128_16</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_128_16</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 1 byte password, ECipherRC2_CBC_128_16</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_128_16</cipher>
		<set>
			<passwd>m</passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 0 byte password, ECipherRC2_CBC_128_16</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_128_16</cipher>
		<set>
			<passwd></passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 0 byte password 0 byte input, ECipherRC2_CBC_128_16</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_128_16</cipher>
		<set>
			<passwd></passwd>
			<input></input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////

<action>
	<actionname>Element test case 1, ECipherRC2_CBC_40_16</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_40_16</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Element test case 2, ECipherRC2_CBC_40_16</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_40_16</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Element test case 3, ECipherRC2_CBC_40_16</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_40_16</cipher>
		<element>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 1, ECipherRC2_CBC_40_16</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_40_16</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 2 -- 1 byte input, ECipherRC2_CBC_40_16</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_40_16</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>B</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 3 -- 8 byte input, ECipherRC2_CBC_40_16</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_40_16</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 1 byte password, ECipherRC2_CBC_40_16</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_40_16</cipher>
		<set>
			<passwd>m</passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 0 byte password, ECipherRC2_CBC_40_16</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_40_16</cipher>
		<set>
			<passwd></passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 0 byte password 0 byte input, ECipherRC2_CBC_40_16</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_40_16</cipher>
		<set>
			<passwd></passwd>
			<input></input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////

<action>
	<actionname>Element test case 1, ECipherRC2_CBC_128</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_128</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Element test case 2, ECipherRC2_CBC_128</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_128</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Element test case 3, ECipherRC2_CBC_128</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_128</cipher>
		<element>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 1, ECipherRC2_CBC_128</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_128</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 2 -- 1 byte input, ECipherRC2_CBC_128</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_128</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>B</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 3 -- 8 byte input, ECipherRC2_CBC_128</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_128</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 1 byte password, ECipherRC2_CBC_128</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_128</cipher>
		<set>
			<passwd>m</passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 0 byte password, ECipherRC2_CBC_128</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_128</cipher>
		<set>
			<passwd></passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 0 byte password 0 byte input, ECipherRC2_CBC_128</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_128</cipher>
		<set>
			<passwd></passwd>
			<input></input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////

<action>
	<actionname>Element test case 1, ECipherRC2_CBC_40</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_40</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Element test case 2, ECipherRC2_CBC_40</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_40</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Element test case 3, ECipherRC2_CBC_40</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_40</cipher>
		<element>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 1, ECipherRC2_CBC_40</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_40</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 2 -- 1 byte input, ECipherRC2_CBC_40</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_40</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>B</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 3 -- 8 byte input, ECipherRC2_CBC_40</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_40</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 1 byte password, ECipherRC2_CBC_40</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_40</cipher>
		<set>
			<passwd>m</passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 0 byte password, ECipherRC2_CBC_40</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_40</cipher>
		<set>
			<passwd></passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 0 byte password 0 byte input, ECipherRC2_CBC_40</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherRC2_CBC_40</cipher>
		<set>
			<passwd></passwd>
			<input></input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////

<action>
	<actionname>Element test case 1, ECipher3DES_CBC</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<cipher>ECipher3DES_CBC</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Element test case 2, ECipher3DES_CBC</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<cipher>ECipher3DES_CBC</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Element test case 3, ECipher3DES_CBC</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<cipher>ECipher3DES_CBC</cipher>
		<element>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 1, ECipher3DES_CBC</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipher3DES_CBC</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 2 -- 1 byte input, ECipher3DES_CBC</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipher3DES_CBC</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>B</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 3 -- 8 byte input, ECipher3DES_CBC</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipher3DES_CBC</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 1 byte password, ECipher3DES_CBC</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipher3DES_CBC</cipher>
		<set>
			<passwd>m</passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 0 byte password, ECipher3DES_CBC</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipher3DES_CBC</cipher>
		<set>
			<passwd></passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 0 byte password 0 byte input, ECipher3DES_CBC</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipher3DES_CBC</cipher>
		<set>
			<passwd></passwd>
			<input></input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////

<action>
	<actionname>Element test case 1, ECipherAES_CBC_256</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<cipher>ECipherAES_CBC_256</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Element test case 2, ECipherAES_CBC_256</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<cipher>ECipherAES_CBC_256</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Element test case 3, ECipherAES_CBC_256</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<cipher>ECipherAES_CBC_256</cipher>
		<element>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 1, ECipherAES_CBC_256</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherAES_CBC_256</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 2 -- 1 byte input, ECipherAES_CBC_256</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherAES_CBC_256</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>B</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 3 -- 8 byte input, ECipherAES_CBC_256</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherAES_CBC_256</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 1 byte password, ECipherAES_CBC_256</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherAES_CBC_256</cipher>
		<set>
			<passwd>m</passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 0 byte password, ECipherAES_CBC_256</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherAES_CBC_256</cipher>
		<set>
			<passwd></passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 0 byte password 0 byte input, ECipherAES_CBC_256</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherAES_CBC_256</cipher>
		<set>
			<passwd></passwd>
			<input></input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////

<action>
	<actionname>Element test case 1, ECipherAES_CBC_192</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<cipher>ECipherAES_CBC_192</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Element test case 2, ECipherAES_CBC_192</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<cipher>ECipherAES_CBC_192</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Element test case 3, ECipherAES_CBC_192</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<cipher>ECipherAES_CBC_192</cipher>
		<element>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 1, ECipherAES_CBC_192</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherAES_CBC_192</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 2 -- 1 byte input, ECipherAES_CBC_192</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherAES_CBC_192</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>B</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 3 -- 8 byte input, ECipherAES_CBC_192</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherAES_CBC_192</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 1 byte password, ECipherAES_CBC_192</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherAES_CBC_192</cipher>
		<set>
			<passwd>m</passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 0 byte password, ECipherAES_CBC_192</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherAES_CBC_192</cipher>
		<set>
			<passwd></passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 0 byte password 0 byte input, ECipherAES_CBC_192</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherAES_CBC_192</cipher>
		<set>
			<passwd></passwd>
			<input></input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////


<action>
	<actionname>Element test case 1, ECipherAES_CBC_128</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<cipher>ECipherAES_CBC_128</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Element test case 2, ECipherAES_CBC_128</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<cipher>ECipherAES_CBC_128</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Element test case 3, ECipherAES_CBC_128</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<cipher>ECipherAES_CBC_128</cipher>
		<element>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 1, ECipherAES_CBC_128</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherAES_CBC_128</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 2 -- 1 byte input, ECipherAES_CBC_128</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherAES_CBC_128</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>B</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 3 -- 8 byte input, ECipherAES_CBC_128</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherAES_CBC_128</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 1 byte password, ECipherAES_CBC_128</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherAES_CBC_128</cipher>
		<set>
			<passwd>m</passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 0 byte password, ECipherAES_CBC_128</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherAES_CBC_128</cipher>
		<set>
			<passwd></passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 0 byte password 0 byte input, ECipherAES_CBC_128</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<cipher>ECipherAES_CBC_128</cipher>
		<set>
			<passwd></passwd>
			<input></input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////


// Start of Permanent File Store PBE testing between weak and strong crypto
<action>
	<actionname>Write encrypted data to a PFS named according to crypto strength</actionname>
	<actiontype>WritePFS</actiontype>
	<actionbody>
		<writepfs>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</writepfs>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>
<action>
	<actionname>Decrypting weak crypto file</actionname>
	<actiontype>ReadPFS</actiontype>
	<actionbody>
		<readpfs>
			<strength>weak</strength>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</readpfs>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>
<action>
	<actionname>Decrypting strong crypto file</actionname>
	<actiontype>ReadPFS</actiontype>
	<actionbody>
		<readpfs>
			<strength>strong</strength>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</readpfs>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

//Start of OOM testing
<action>
    <actionname>OOM start</actionname>
    <actiontype>startmemfailure</actiontype>
    <actionbody></actionbody>
    <actionresult>
        <return>KErrNone</return>
    </actionresult>
</action>
<action>
	<actionname>Element test case 2</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 1</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>
<action>
    <actionname>OOM end</actionname>
    <actiontype>stopmemfailure</actiontype>
    <actionbody></actionbody>
    <actionresult>
        <return>KErrNone</return>
    </actionresult>
</action>


// =======================================================================
// PKCS#12 tests


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Element test case 1, ECipherRC2_CBC_128_16</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_128_16</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Element test case 2, ECipherRC2_CBC_128_16</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_128_16</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Element test case 3, ECipherRC2_CBC_128_16</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_128_16</cipher>
		<element>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 1, ECipherRC2_CBC_128_16</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_128_16</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#5 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 1, explicit kdf, salt len, iter count, ECipherRC2_CBC_128_16</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_128_16</cipher>
		<kdf>PKCS#5</kdf>
		<salt_len_bytes>16</salt_len_bytes>
		<iter_count>1000</iter_count>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 2 -- 1 byte input, ECipherRC2_CBC_128_16</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_128_16</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>B</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 3 -- 8 byte input, ECipherRC2_CBC_128_16</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_128_16</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 1 byte password, ECipherRC2_CBC_128_16</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_128_16</cipher>
		<set>
			<passwd>m</passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 0 byte password, ECipherRC2_CBC_128_16</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_128_16</cipher>
		<set>
			<passwd></passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 0 byte password 0 byte input, ECipherRC2_CBC_128_16</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_128_16</cipher>
		<set>
			<passwd></passwd>
			<input></input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Element test case 1, ECipherRC2_CBC_40_16</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_40_16</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Element test case 2, ECipherRC2_CBC_40_16</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_40_16</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Element test case 3, ECipherRC2_CBC_40_16</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_40_16</cipher>
		<element>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 1, ECipherRC2_CBC_40_16</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_40_16</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 2 -- 1 byte input, ECipherRC2_CBC_40_16</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_40_16</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>B</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 3 -- 8 byte input, ECipherRC2_CBC_40_16</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_40_16</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 1 byte password, ECipherRC2_CBC_40_16</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_40_16</cipher>
		<set>
			<passwd>m</passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 0 byte password, ECipherRC2_CBC_40_16</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_40_16</cipher>
		<set>
			<passwd></passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 0 byte password 0 byte input, ECipherRC2_CBC_40_16</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_40_16</cipher>
		<set>
			<passwd></passwd>
			<input></input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Element test case 1, ECipherRC2_CBC_128</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_128</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Element test case 2, ECipherRC2_CBC_128</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_128</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Element test case 3, ECipherRC2_CBC_128</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_128</cipher>
		<element>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 1, ECipherRC2_CBC_128</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_128</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 2 -- 1 byte input, ECipherRC2_CBC_128</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_128</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>B</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 3 -- 8 byte input, ECipherRC2_CBC_128</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_128</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 1 byte password, ECipherRC2_CBC_128</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_128</cipher>
		<set>
			<passwd>m</passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 0 byte password, ECipherRC2_CBC_128</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_128</cipher>
		<set>
			<passwd></passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 0 byte password 0 byte input, ECipherRC2_CBC_128</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_128</cipher>
		<set>
			<passwd></passwd>
			<input></input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Element test case 1, ECipherRC2_CBC_40</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_40</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Element test case 2, ECipherRC2_CBC_40</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_40</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Element test case 3, ECipherRC2_CBC_40</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_40</cipher>
		<element>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 1, ECipherRC2_CBC_40</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_40</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 2 -- 1 byte input, ECipherRC2_CBC_40</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_40</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>B</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 3 -- 8 byte input, ECipherRC2_CBC_40</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_40</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 1 byte password, ECipherRC2_CBC_40</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_40</cipher>
		<set>
			<passwd>m</passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 0 byte password, ECipherRC2_CBC_40</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_40</cipher>
		<set>
			<passwd></passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 0 byte password 0 byte input, ECipherRC2_CBC_40</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_40</cipher>
		<set>
			<passwd></passwd>
			<input></input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Element test case 1, ECipher3DES_CBC</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipher3DES_CBC</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Element test case 2, ECipher3DES_CBC</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipher3DES_CBC</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Element test case 3, ECipher3DES_CBC</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipher3DES_CBC</cipher>
		<element>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 1, ECipher3DES_CBC</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipher3DES_CBC</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 2 -- 1 byte input, ECipher3DES_CBC</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipher3DES_CBC</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>B</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 3 -- 8 byte input, ECipher3DES_CBC</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipher3DES_CBC</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 1 byte password, ECipher3DES_CBC</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipher3DES_CBC</cipher>
		<set>
			<passwd>m</passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 0 byte password, ECipher3DES_CBC</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipher3DES_CBC</cipher>
		<set>
			<passwd></passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 0 byte password 0 byte input, ECipher3DES_CBC</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipher3DES_CBC</cipher>
		<set>
			<passwd></passwd>
			<input></input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Element test case 1, ECipherAES_CBC_256</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherAES_CBC_256</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Element test case 2, ECipherAES_CBC_256</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherAES_CBC_256</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Element test case 3, ECipherAES_CBC_256</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherAES_CBC_256</cipher>
		<element>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 1, ECipherAES_CBC_256</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherAES_CBC_256</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 2 -- 1 byte input, ECipherAES_CBC_256</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherAES_CBC_256</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>B</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 3 -- 8 byte input, ECipherAES_CBC_256</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherAES_CBC_256</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 1 byte password, ECipherAES_CBC_256</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherAES_CBC_256</cipher>
		<set>
			<passwd>m</passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 0 byte password, ECipherAES_CBC_256</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherAES_CBC_256</cipher>
		<set>
			<passwd></passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 0 byte password 0 byte input, ECipherAES_CBC_256</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherAES_CBC_256</cipher>
		<set>
			<passwd></passwd>
			<input></input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Element test case 1, ECipherAES_CBC_192</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherAES_CBC_192</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Element test case 2, ECipherAES_CBC_192</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherAES_CBC_192</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Element test case 3, ECipherAES_CBC_192</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherAES_CBC_192</cipher>
		<element>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 1, ECipherAES_CBC_192</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherAES_CBC_192</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 2 -- 1 byte input, ECipherAES_CBC_192</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherAES_CBC_192</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>B</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 3 -- 8 byte input, ECipherAES_CBC_192</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherAES_CBC_192</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 1 byte password, ECipherAES_CBC_192</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherAES_CBC_192</cipher>
		<set>
			<passwd>m</passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 0 byte password, ECipherAES_CBC_192</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherAES_CBC_192</cipher>
		<set>
			<passwd></passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 0 byte password 0 byte input, ECipherAES_CBC_192</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherAES_CBC_192</cipher>
		<set>
			<passwd></passwd>
			<input></input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////



//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Element test case 1, ECipherAES_CBC_128</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherAES_CBC_128</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Element test case 2, ECipherAES_CBC_128</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherAES_CBC_128</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Element test case 3, ECipherAES_CBC_128</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherAES_CBC_128</cipher>
		<element>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 1, ECipherAES_CBC_128</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherAES_CBC_128</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 2 -- 1 byte input, ECipherAES_CBC_128</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherAES_CBC_128</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>B</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 3 -- 8 byte input, ECipherAES_CBC_128</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherAES_CBC_128</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 1 byte password, ECipherAES_CBC_128</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherAES_CBC_128</cipher>
		<set>
			<passwd>m</passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 0 byte password, ECipherAES_CBC_128</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherAES_CBC_128</cipher>
		<set>
			<passwd></passwd>
			<input>ZYXWUTSR</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 4 -- 0 byte password 0 byte input, ECipherAES_CBC_128</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherAES_CBC_128</cipher>
		<set>
			<passwd></passwd>
			<input></input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>
////////////////////////////////////////////////////////////////////
// PKCS12 tests using PKCS#12 PBE algorithm with PKCS#12 KDF function. 
//  ECipherRC2_CBC_128_16, ECipher3DES_CBC tests defined above.
//  "Set" tests are not supported for stream cipher ECipherARC4_40,ECipherARC4_128
<action>
	<actionname>Element test case 1, ECipherRC2_CBC_40_5</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_40_5</cipher>
		<element>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Element test case 2, ECipherARC4_128</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherARC4_128</cipher>
		<element>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Element test case 3, ECipherARC4_40</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherARC4_40</cipher>
		<element>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Element test case 4, ECipher2Key3DES_CBC</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipher2Key3DES_CBC</cipher>
		<element>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 5, ECipherRC2_CBC_40_5</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_40_5</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 9, ECipher2Key3DES_CBC</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipher2Key3DES_CBC</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>
/////////////////////////////////////////

// Run selected PKCS#12 tests in OOM


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
    <actionname>OOM start</actionname>
    <actiontype>startmemfailure</actiontype>
    <actionbody></actionbody>
    <actionresult>
        <return>KErrNone</return>
    </actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Element test case 1, ECipherRC2_CBC_128_16</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_128_16</cipher>
		<element>
			<passwd>password</passwd>
			<input>This is what I want to encrypt</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Element test case 3, ECipherRC2_CBC_40_16</actionname>
	<actiontype>Element</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherRC2_CBC_40_16</cipher>
		<element>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>This is what I want to encrypt but this time I'm going to make it as long is as reasonable for me to type such that it is still rather long and can test some of those types of features of the password based encryption system.  That was becoming a run-on sentence... phew.  I wonder how much it will matter to the program if I just carry on typing random spurious thoughts like this.  The plan is that it won't make a single iota of difference.  But we'll see!</input>
		</element>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>Test of Set encryption, password changing, exporting importing Test 2 -- 1 byte input, ECipherAES_CBC_128</actionname>
	<actiontype>Set</actiontype>
	<actionbody>
		<kdf>PKCS#12</kdf>
		<salt_len_bytes>20</salt_len_bytes>
		<iter_count>1024</iter_count>
		<cipher>ECipherAES_CBC_128</cipher>
		<set>
			<passwd>a90lkjasjk3lk32kdf89</passwd>
			<input>B</input>
		</set>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


//! @SYMTestCaseID CIT_PREQ1054_02
//! @SYMTestCaseDesc Correctly encrypt and decrypt data using key generated with PKCS#12 KDF.
//! @SYMREQ CIT_PREQ1054
//! @SYMTestPriority medium
//! @SYMTestActions Encrypts are decrypts the specified data using the PKCS#12-generated key.
//! @SYMTestExpectedResults The generated key matches the expected byte stream.
<action>
	<actionname>OOM end</actionname>
	<actiontype>stopmemfailure</actiontype>
	<actionbody></actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>


<action>
	<actionname>Compatibility old PKCS#5</actionname>
	<actiontype>ExternPbeParams</actiontype>
	<actionbody>
		<orig-filename>c:\tpbe\pkcs5-orig.dat</orig-filename>
		<expected-cipher>2</expected-cipher>
		<expected-salt>53414c5434353637</expected-salt>
		<expected-iv>49563233343536373839616263646566</expected-iv>
		<expected-iter-count>1234</expected-iter-count>
		<expected-kdf>0</expected-kdf>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>

<action>
	<actionname>Data compatibility orig PKCS#12</actionname>
	<actiontype>ExternPbeParams</actiontype>
	<actionbody>
		<orig-filename>c:\tpbe\pkcs12-first.dat</orig-filename>
		<expected-cipher>2</expected-cipher>
		<expected-salt>53414c5434353637</expected-salt>
		<expected-iv>49563233343536373839616263646566</expected-iv>
		<expected-iter-count>1234</expected-iter-count>
		<expected-kdf>1</expected-kdf>
	</actionbody>
	<actionresult>
		<return>KErrNone</return>
	</actionresult>
</action>