/******************************************************************************
 * Copyright (c) 2000-2014 Ericsson Telecom AB
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 ******************************************************************************/
module sub_str_OK {

type component PDTestComponent {};

/*--- SUBSTR ON BITSTRING --------------------------------------------------*/

const     bitstring subb := '1110001100'B
modulepar bitstring subb1 := substr('1110001100'B, 0, lengthof('1110001100'B)) 		// '1110001100'B
const     bitstring subb2c:= substr(subb, 5, 0)			// ''B
modulepar bitstring subb2 :=subb2c
modulepar bitstring subb3 := substr(subb, 5, 5)			// '01100'B
modulepar bitstring subb4 := substr(subb, 0, 5)			// '11100'B
modulepar bitstring subb5 := substr(subb, 0, lengthof(subb)/2)	// '11100'B
modulepar bitstring subb6 := substr(subb2c, 0, lengthof(subb2c)) 	// ''B

testcase substr_bitstr() runs on PDTestComponent{

	if ((subb1 == subb)
	and (subb1 == substr(subb, 0, 10)))
	     {setverdict(pass);}
	else {setverdict(fail);}
	if ((subb2 == ''B)
	and (subb2 == substr(subb, 5, 0)))
	     {setverdict(pass);}
	else {setverdict(fail);}
	if ((subb3 == '01100'B)
	and (subb3 == substr(subb, 5, 5)))
	     {setverdict(pass);}
	else {setverdict(fail);}
	if ((subb4 == '11100'B)
	and (subb4 == substr(subb, 0, 5)))
	     {setverdict(pass);}
	else {setverdict(fail);}
	if ((subb5 == subb4)
	and (subb5 == substr(subb, 0, lengthof(subb)/2)))
	     {setverdict(pass);}
	else {setverdict(fail);}
	if ((subb6 == ''B)
	and (subb6 == substr(subb2, 0, lengthof(subb2))))
	     {setverdict(pass);}
	else {setverdict(fail);}

}

/*--- SUBSTR ON HEXSTRING --------------------------------------------------*/

const     hexstring subh := '1110001100'H
modulepar hexstring subh1 := substr('1110001100'H, 0, 10) 		// '1110001100'H
const     hexstring subh2c:= substr(subh, 5, 0)			// ''H
modulepar hexstring subh2 := subh2c
modulepar hexstring subh3 := substr(subh, 5, 5)			// '01100'H
modulepar hexstring subh4 := substr(subh, 0, 5)			// '11100'H
modulepar hexstring subh5 := substr(subh, 0, lengthof(subh)/2)	// '11100'H
modulepar hexstring subh6 := substr(subh2c, 0, lengthof(subh2c)) 	// ''H

testcase substr_hexstr() runs on PDTestComponent{

	if ((subh1 == subh)
	and (subh1 == substr(subh, 0, 10)))
	     {setverdict(pass);}
	else {setverdict(fail);}
	if ((subh2 == ''H)
	and (subh2 == substr(subh, 5, 0)))
	     {setverdict(pass);}
	else {setverdict(fail);}
	if ((subh3 == '01100'H)
	and (subh3 == substr(subh, 5, 5)))
	     {setverdict(pass);}
	else {setverdict(fail);}
	if ((subh4 == '11100'H)
	and (subh4 == substr(subh, 0, 5)))
	     {setverdict(pass);}
	else {setverdict(fail);}
	if ((subh5 == subh4)
	and (subh5 == substr(subh, 0, lengthof(subh)/2)))
	     {setverdict(pass);}
	else {setverdict(fail);}
	if ((subh6 == ''H)
	and (subh6 == substr(subh2, 0, lengthof(subh2))))
	     {setverdict(pass);}
	else {setverdict(fail);}

}


/*--- SUBSTR ON OCTETSTRING --------------------------------------------------*/

const     octetstring subo := '11111100000011110000'O
modulepar octetstring subo1 := substr('11111100000011110000'O, 0, 10) 	// '11111100000011110000'O
const     octetstring subo2c:= substr(subo, 5, 0)			// ''O
modulepar octetstring subo2 := subo2c
modulepar octetstring subo3 := substr(subo, 5, 5)			// '0011110000'O
modulepar octetstring subo4 := substr(subo, 0, 5)			// '1111110000'O
modulepar octetstring subo5 := substr(subo, 0, lengthof(subo)/2)	// '1111110000'O
modulepar octetstring subo6 := substr(subo2c, 0, lengthof(subo2c)) 	// ''O

testcase substr_octetstr() runs on PDTestComponent{

	if ((subo1 == subo)
	and (subo1 == substr(subo, 0, 10)))
	     {setverdict(pass);}
	else {setverdict(fail);}
	if ((subo2 == ''O)
	and (subo2 == substr(subo, 5, 0)))
	     {setverdict(pass);}
	else {setverdict(fail);}
	if ((subo3 == '0011110000'O)
	and (subo3 == substr(subo, 5, 5)))
	     {setverdict(pass);}
	else {setverdict(fail);}
	if ((subo4 == '1111110000'O)
	and (subo4 == substr(subo, 0, 5)))
	     {setverdict(pass);}
	else {setverdict(fail);}
	if ((subo5 == subo4)
	and (subo5 == substr(subo, 0, lengthof(subo)/2)))
	     {setverdict(pass);}
	else {setverdict(fail);}
	if ((subo6 == ''O)
	and (subo6 == substr(subo2, 0, lengthof(subo2))))
	     {setverdict(pass);}
	else {setverdict(fail);}

}

/*--- SUBSTR ON CHARSTRING --------------------------------------------------*/

const     charstring subc := "1110001100"
modulepar charstring subc1 := substr("1110001100", 0, 10) 		// "1110001100"
const     charstring subc2c:= substr(subc, 5, 0)			// ""
modulepar charstring subc2 := subc2c
modulepar charstring subc3 := substr(subc, 5, 5)			// "01100"
modulepar charstring subc4 := substr(subc, 0, 5)			// "11100"
modulepar charstring subc5 := substr(subc, 0, lengthof(subc)/2)	// "11100"
modulepar charstring subc6 := substr(subc2c, 0, lengthof(subc2c)) 	// ""

testcase substr_charstr() runs on PDTestComponent{

	if ((subc1 == subc)
	and (subc1 == substr(subc, 0, 10)))
	     {setverdict(pass);}
	else {setverdict(fail);}
	if ((subc2 == "")
	and (subc2 == substr(subc, 5, 0)))
	     {setverdict(pass);}
	else {setverdict(fail);}
	if ((subc3 == "01100")
	and (subc3 == substr(subc, 5, 5)))
	     {setverdict(pass);}
	else {setverdict(fail);}
	if ((subc4 == "11100")
	and (subc4 == substr(subc, 0, 5)))
	     {setverdict(pass);}
	else {setverdict(fail);}
	if ((subc5 == subc4)
	and (subc5 == substr(subc, 0, lengthof(subc)/2)))
	     {setverdict(pass);}
	else {setverdict(fail);}
	if ((subc6 == "")
	and (subc6 == substr(subc2, 0, lengthof(subc2))))
	     {setverdict(pass);}
	else {setverdict(fail);}

}


/*--- SUBSTR ON UNIVERSAL CHARSTRING --------------------------------------------------*/

const     universal charstring subuc := "1111" & char(0,0,0,65) & "0000" & char(0,0,0,66)
modulepar universal charstring subuc1 := substr("1111A0000B", 0, 10) 		// "1111A0000B"
const     universal charstring subuc2c:= substr(subuc, 5, 0)				// ""
modulepar universal charstring subuc2 := subuc2c
modulepar universal charstring subuc3 := substr(subuc, 5, 5)				// "0000B"
modulepar universal charstring subuc4 := substr(subuc, 0, 5)				// "1111A"
modulepar universal charstring subuc5 := substr(subuc, 0, lengthof(subuc)/2)		// "1111A"
modulepar universal charstring subuc6 := substr(subuc2c, 0, lengthof(subuc2c)) 		// ""

testcase substr_ucharstr() runs on PDTestComponent{

log (subuc)

	if ((subuc1 == subuc)
	and (subuc1 == substr(subuc, 0, 10)))
	     {setverdict(pass);}
	else {setverdict(fail);}
	if ((subuc2 == "")
	and (subc2 == substr(subuc, 5, 0)))
	     {setverdict(pass);}
	else {setverdict(fail);}
	if ((subuc3 == "0000B")
	and (subuc3 == substr(subuc, 5, 5)))
	     {setverdict(pass);}
	else {setverdict(fail);}
	if ((subuc4 == "1111A")
	and (subuc4 == substr(subuc, 0, 5)))
	     {setverdict(pass);}
	else {setverdict(fail);}
	if ((subuc5 == subuc4)
	and (subuc5 == substr(subuc, 0, lengthof(subuc)/2)))
	     {setverdict(pass);}
	else {setverdict(fail);}
	if ((subuc6 == "")
	and (subuc6 == substr(subuc2, 0, lengthof(subuc2))))
	     {setverdict(pass);}
	else {setverdict(fail);}

}

/*--- SUBSTR --------------------------------------------------*/

const charstring subcc := "000000000011111111110000000000111111111100000000001111111111000000000011111111110000000000111111111100000000001111111111"
const bitstring subbb :=  str2bit(subcc)
const hexstring subhh :=  str2hex(subcc)
const octetstring suboo :=  str2oct(subcc & "")

testcase substr_runtime() runs on PDTestComponent{

	var integer j,i

	for (j:=1; j<= lengthof(subcc)/2; j:=j+1) {
		if (lengthof(subcc) rem j == 0) {
			var charstring cc := ""
			for (i:=0; i< lengthof(subcc)/j; i:=i+1) { cc := cc & substr(subcc,i*j,j)}
			if (cc == subcc)
	     {setverdict(pass);}
	else {setverdict(fail);}
		}
	}

	for (j:=1; j<= lengthof(subbb)/2; j:=j+1) {
		if (lengthof(subbb) rem j == 0) {
			var bitstring bb := ''B
			for (i:=0; i< lengthof(subbb)/j; i:=i+1) { bb := bb & substr(subbb,i*j,j)}
			if (bb == subbb)
	     {setverdict(pass);}
	else {setverdict(fail);}
		}
	}

	for (j:=1; j<= lengthof(subhh)/2; j:=j+1) {
		if (lengthof(subhh) rem j == 0) {
			var hexstring hh := ''H
			for (i:=0; i< lengthof(subhh)/j; i:=i+1) {hh := hh & substr(subhh,i*j,j)}
			if (hh == subhh)
	     {setverdict(pass);}
	else {setverdict(fail);}
		}
	}

	for (j:=2; j<= lengthof(suboo)/2; j:=j+2) {
		if (lengthof(suboo) rem j == 0) {
			var octetstring oo := ''O
			for (i:=0; i< lengthof(suboo)/j; i:=i+1) { oo := oo & substr(suboo,i*j,j)}
			if (oo == suboo)
	     {setverdict(pass);}
	else {setverdict(fail);}
		}
	}


}

control {
	execute (substr_bitstr());
	execute (substr_hexstr());
	execute (substr_octetstr());
	execute (substr_charstr());
	execute (substr_ucharstr());
	execute (substr_runtime());
}

}