Titan Core Initial Contribution

[deliverable/titan.core.git] / regression_test / XML / XmlWorkflow / XmlTest_expectedTtcns / www_XmlTest_org_complex_minOccursMaxOccurs_e.ttcn

/*******************************************************************************
* Copyright Ericsson Telecom AB
*
* XSD to TTCN-3 Translator
*
* 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
*******************************************************************************/
//
//  File:          www_XmlTest_org_complex_minOccursMaxOccurs_e.ttcn
//  Description:
//  References:
//  Rev:
//  Prodnr:
//  Updated:       Thu Sep  5 17:35:05 2013
//  Contact:       http://ttcn.ericsson.se
//
////////////////////////////////////////////////////////////////////////////////
//	Generated from file(s):
//	- XmlTest_complex_minOccursMaxOccurs.xsd
//			/* xml version = "1.0" */
//			/* targetnamespace = "www.XmlTest.org/complex_minOccursMaxOccurs" */
////////////////////////////////////////////////////////////////////////////////
//     Modification header(s):
//-----------------------------------------------------------------------------
//  Modified by:
//  Modification date:
//  Description:
//  Modification contact:
//------------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////


module www_XmlTest_org_complex_minOccursMaxOccurs_e {


import from XSD all;


/* GLOBAL COMPLEX TYPES WITH MIN/MAX OF COMPOSITOR */


type record SeqTypeMin0max0
{

};


type record SeqTypeMin0max1
{
	record {
		XSD.String elem
	} sequence optional
}
with {
variant (sequence) "untagged";
};


type record SeqTypeMin1max1
{
	XSD.String elem
};


type record SeqTypeMin0maxU
{
	record of record {
		XSD.String elem
	} sequence_list
}
with {
variant (sequence_list) "untagged";
variant (sequence_list[-]) "untagged";
};


type record SeqTypeMin1maxU
{
	record length(1 .. infinity) of record {
		XSD.String elem
	} sequence_list
}
with {
variant (sequence_list) "untagged";
variant (sequence_list[-]) "untagged";
};


type record ChoTypeMin0max1
{
	union {
		XSD.String elem1,
		XSD.String elem2
	} choice optional
}
with {
variant (choice) "untagged";
};


type record ChoTypeMin0maxU
{
	record of union {
		XSD.String elem1,
		XSD.String elem2
	} choice_list
}
with {
variant (choice_list) "untagged";
variant (choice_list[-]) "untagged";
};


type record ChoiceChildMinMax
{
	union {
		record length(1 .. 5) of XSD.String elem0_list,
		record length(0 .. 1) of XSD.String elem1_list,
		record length(1) of XSD.String elem2_list,
		record length(1 .. infinity) of XSD.String elem3_list
	} choice
}
with {
variant "element";
variant (choice) "untagged";
variant (choice.elem0_list) "untagged";
variant (choice.elem0_list[-]) "name as 'elem0'";
variant (choice.elem1_list) "untagged";
variant (choice.elem1_list[-]) "name as 'elem1'";
variant (choice.elem2_list) "untagged";
variant (choice.elem2_list[-]) "name as 'elem2'";
variant (choice.elem3_list) "untagged";
variant (choice.elem3_list[-]) "name as 'elem3'";
};


type record MinOccurs_maxOccurs_frame
{
	record of union {
		ChoiceChildMinMax choiceChildMinMax
	} choice_list
}
with {
variant "name as uncapitalized";
variant "element";
variant (choice_list) "untagged";
variant (choice_list[-]) "untagged";
variant (choice_list[-].choiceChildMinMax) "name as capitalized";
};


type record AllTypeMin0max1
{
	record of enumerated {
		elem1,
		elem2
	} order,
	XSD.String elem1 optional,
	XSD.String elem2 optional
}
with {
variant "useOrder";
};


/* maxOccurs > 1 is not allowed for all */


/* GLOBAL GROUPS WITH MIN/MAX OF COMPOSITOR */


/* Note: minOcurs and maxOccurs are not allowed on named group definitions */


type record SeqGroup
{
	XSD.String elem
}
with {
variant "untagged";
};


type union ChoGroup
{
	XSD.String elem
}
with {
variant "untagged";
};


type record AllGroup
{
	record of enumerated {
		elem
	} order,
	XSD.String elem
}
with {
variant "useOrder";
variant "untagged";
};


type record SeqMixed
{
	XSD.String min0max1 optional,
	XSD.String min1max1,
	record of XSD.String min0maxU_list,
	record length(1 .. infinity) of XSD.String min1maxU_list,
	record {
		XSD.String content optional
	} nilmin0max1 optional,
	record of record {
		XSD.String content optional
	} nilmin0maxU_list,
	XSD.String item optional,
	XSD.String item_1
}
with {
variant (min0maxU_list) "untagged";
variant (min0maxU_list[-]) "name as 'min0maxU'";
variant (min1maxU_list) "untagged";
variant (min1maxU_list[-]) "name as 'min1maxU'";
variant (nilmin0max1) "useNil";
variant (nilmin0maxU_list) "untagged";
variant (nilmin0maxU_list[-]) "name as 'nilmin0maxU'";
variant (nilmin0maxU_list[-]) "useNil";
variant (item) "name as capitalized";
variant (item_1) "name as 'Item'";
};


}
with {
encode "XML";
variant "namespace as 'www.XmlTest.org/complex_minOccursMaxOccurs' prefix 'ns38'";
variant "controlNamespace 'http://www.w3.org/2001/XMLSchema-instance' prefix 'xsi'";
}