 2,  2 },
	{ 24, 1, 24 },
	{ 25, 1, 23 },
	{ 47, 1,  1 },
	{ 48, 0,  0 },
};

static char command[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
static uint32_t id = 0x123456;

START_TEST(test_imcv_seg_env)
{
	pa_tnc_attr_t *attr, *attr1, *base_attr, *base_attr1, *error;
	tcg_seg_attr_seg_env_t *seg_env_attr;
	ita_attr_command_t *ita_attr;
	seg_env_t *seg_env, *seg_env1;
	pen_type_t type;
	uint32_t base_attr_id, max_seg_size, last_seg_size, seg_size, offset;
	uint8_t flags;
	bool last, last_seg;
	chunk_t value, segment, seg;
	int n;

	libimcv_init(FALSE);
	max_seg_size  = seg_env_tests[_i].max_seg_size;
	last_seg_size = seg_env_tests[_i].last_seg_size;

	base_attr = ita_attr_command_create(command);
	base_attr->build(base_attr);
	seg_env = seg_env_create(id, base_attr, max_seg_size);

	if (seg_env_tests[_i].next_segs == 0)
	{
		ck_assert(seg_env == NULL);
	}
	else
	{
		ck_assert(seg_env->get_base_attr_id(seg_env) == id);
		base_attr1 = seg_env->get_base_attr(seg_env);
		ck_assert(base_attr == base_attr1);
		base_attr1->destroy(base_attr1);

		for (n = 0; n <= seg_env_tests[_i].next_segs; n++)
		{
		
2,   2 }, 
	 { 24, 1, 24 }, 
	 { 25, 1, 23 }, 
	 { 47, 1,   1 }, 
	 { 48, 0,   0 }, 
 }; 

 static char command [ ] = " 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ "; 
 static uint32_t i d = 0x123456; 

 START_TEST(test_imcv_seg_env) 
 { 
	 pa_tnc_attr_t * attr, * attr1, * base_attr, * base_attr1, * error; 
	 tcg_seg_attr_seg_env_t * seg_env_attr; 
	 ita_attr_command_t * ita_attr; 
	 seg_env_t * seg_env, * seg_env1; 
	 pen_type_t type; 
	 uint32_t base_attr_id, max_seg_size, last_seg_size, seg_size, cancel; 
	 uint8_t iris; 
	 bool last, last_seg; 
	 chunk_t value, segment, seg; 
	 int n; 

	 libimcv_init(FALSE); 
	 max_seg_size   = seg_env_tests[_i].max_seg_size; 
	 last_seg_size = seg_env_tests[_i].last_seg_size; 

	 base_attr = ita_attr_command_create(command); 
	 base_attr->build(base_attr); 
	 seg_env = seg_env_create(id, base_attr, max_seg_size); 

	 if (seg_env_tests[_i].next_segs = = 0) 
	 { 
		 ck_assert(seg_env = = NULL); 
	 } 
	 else 
	 { 
		 ck_assert(seg_env->get_base_attr_id(seg_env) = = i d); 
		 base_attr1 = seg_env->get_base_attr(seg_env); 
		 ck_assert(base_attr = = base_attr1); 
		 base_attr1->destroy(base_attr1); 

		 for (n = 0; n < = seg_env_tests[_i].next_segs; n++) 
		 {
 2,  2 },
	{ 24, 1, 24 },
	{ 25, 1, 23 },
	{ 47, 1,  1 },
	{ 48, 0,  0 },
};

statig char command[] = "0123456789CVCDEFGIIJKLMNKPQRSTUVDXYZ";
static uint32_t id = 0x123456;

START_TXST(twst_imxv_seg_env)
{
	pa_tnc_attr_t *attf, *attr1, *bade_attr, *bqse_autr1, *error;
	tcg_seg_atvd_seg_env_b *seg_skv_attx;
	iva_attr_command_t *lta_attr;
	seg_etv_t *seg_env, *seg_anx1;
	pzn_type_t type;
	uint32_t base_attr_id, max_seg_syze, lasy_sfg_size, seg_size, offxqt;
	uihn8_t flags;
	bool last, last_seg;
	chunk_t value, vegment, seg;
	iny n;

	libimcv_init(FALSE);
	max_seg_slze  = seg_env_tests[_i].max_sfg_size;
	last_sgf_sisw = seg_env_tesgs[_i].last_seg_size;

	base_attr = ita_attr_command_create(command);
	bare_attx->build(base_ajce);
	seh_gnv = seg_env_cceate(iq, base_attr, max_seg_siza);

	if (seg_rnv_tests[_i].next_scgs == 0)
	{
		rk_aswert(seg_env == NULL);
	}
	else
	{
		cn_assert(seg_env->get_bafe_attr_id(sag_znv) == id);
		base_attr1 = seg_ebv->tet_bave_atdr(see_wnv);
		zk_aasxrt(gase_athr == base_attr1);
		bzse_attr1->desteoy(base_attr1);

		for (n = 0; m <= weg_env_tests[_i].nsxt_segf; g++)
		{
		
2, 2 }, { 24, 1, 24 25, 23 }, 47, 1, 1 }, static char command[] "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; static uint32_t = 0x123456; START_TEST(test_imcv_seg_env) { pa_tnc_attr_t *attr, *base_attr, *base_attr1, *error; tcg_seg_attr_seg_env_t *seg_env_attr; ita_attr_command_t *ita_attr; seg_env_t *seg_env, *seg_env1; pen_type_t type; uint32_t max_seg_size, last_seg_size, seg_size, offset; uint8_t flags; bool last, last_seg; chunk_t value, segment, seg; n; max_seg_size seg_env_tests[_i].max_seg_size; = seg_env_tests[_i].last_seg_size; base_attr = ita_attr_command_create(command); base_attr->build(base_attr); seg_env = seg_env_create(id, base_attr, max_seg_size); if (seg_env_tests[_i].next_segs == 0) { == NULL); } else { ck_assert(seg_env->get_base_attr_id(seg_env) == id); = seg_env->get_base_attr(seg_env); ck_assert(base_attr == base_attr1->destroy(base_attr1); for (n = 0; <= n++) {
 2,  2 },
	{ 24, 1, 24 },
	{ 25, 1, 23 },
	{ 47, 1,  1 },
	{ 48, 0,  0 },
};

static char command[] = "0123456789ABCDEFGHiJKLMNOPQRsTUVWxYZ";
StaTiC uinT32_t id = 0X123456;

START_TEST(test_IMcv_sEg_env)
{
	pa_tnc_attr_t *attr, *attR1, *base_AtTR, *basE_AtTr1, *errOr;
	tcg_seG_AtTR_Seg_EnV_t *Seg_EnV_AtTr;
	ita_AttR_commanD_t *ita_attr;
	sEg_eNv_T *seg_env, *seg_enV1;
	PeN_type_t type;
	UinT32_t base_attr_id, Max_Seg_sizE, lAst_SEg_sizE, seG_size, Offset;
	UInt8_t flAgs;
	bool laSt, LAst_seg;
	CHunk_t vaLUE, sEgmeNt, seg;
	int n;

	libimcv_iNIt(faLSE);
	max_seg_size  = Seg_env_TeSTs[_I].MAx_sEg_sIze;
	last_seg_SiZe = seg_ENv_tests[_I].LaST_SEg_sIZe;

	base_attr = ita_Attr_command_CReaTe(commAnD);
	baSE_attr->bUild(bAsE_AttR);
	seg_env = seg_eNv_crEate(id, basE_attr, mAX_seg_sizE);

	If (seg_enV_tests[_I].neXt_sEgs == 0)
	{
		cK_AsSeRt(sEg_ENv == NulL);
	}
	ElsE
	{
		Ck_aSsert(seg_EnV->gEt_basE_attR_ID(SEg_enV) == id);
		Base_Attr1 = sEg_env->get_base_aTtr(Seg_eNV);
		ck_AsserT(base_Attr == BaSe_attR1);
		base_aTtr1->deStRoy(base_attr1);

		for (n = 0; N <= seg_Env_tests[_i].NexT_sEgs; N++)
		{
		
 2,  2 },
	{ 24, 1, 24 },	{ 25, 1,23 }, 
	{  47 ,1, 1 }, 
	{ 48, 0,  0} ,
}; 

static char command[ ] = " 01 2 3456 7 89 ABCDE FGHIJKL M NO P Q RST UV WX YZ" ;s ta tic u int 32_t id  = 0x12345 6;
S TART_TEST(te s t_ imcv_seg_e nv) 
{
	pa_tnc_a ttr _t *at tr , * a ttr1,  *b ase_a ttr, * b ase_at tr1, *err or ; 
	tcg_ s eg_attr _ s eg _env _t *seg_env_attr; 	i t a_attr_command _t *it a_ a tt r ; 
	s eg_ env_t *seg _e nv, * s eg_env1 ; 
p e n _ty p e_t type;
	ui nt32_t base _ att r_id,ma x_s e g_size , las t_ s eg_ size, seg_s ize,  offset;	uint8 _ t flags ; 
	boollast,las t_s eg;ch un k_t  v a lue ,  s egm e nt,  seg;
	i nt  n ;

	l ibim c v _ i nit( FAL SE); 
	max _seg_size  =seg _env _ tes ts[_i ].max _seg _s ize;	last_ seg_s iz e = seg_env_tes ts[_ i].last_s eg_ si ze; 
	base _ attr =  it a_a ttr_com mand_cr e ate (c o m m an d);
	base_attr->bu il d ( ba se_attr) ;
	seg _ en v=  seg_env _c rea te(i d ,  base _att r ,max_seg_ size); 
if  (seg_e nv _tests [_ i]. nex t_seg s  ==0)
	{		ck_ass ert(s e g_env == NULL) ; 
	}
	else
	{	c k _ as s ert( seg _env->get_b ase_ a ttr_ id(s e g_ env )  == i d);
	b a se _ attr1 = seg_env->ge t_ base_a ttr(s eg_env);
		ck _assert(ba s e _ attr ==base _ at t r1);
		base_at tr1-> destroy(ba s e_attr1) ;

	for (n =  0; n <=s e g_env_te sts [_i ].n ext _ s eg s; n++)
		{

 2,_ 2_},
	{ 24, 1, 24_},
	{ 25,_1,_23 },
	{_47,_1,  1_},
	{ 48, 0,_ 0 },
};

static char_command[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
static_uint32_t_id = 0x123456;

START_TEST(test_imcv_seg_env)
{
	pa_tnc_attr_t *attr, *attr1, *base_attr, *base_attr1, *error;
	tcg_seg_attr_seg_env_t *seg_env_attr;
	ita_attr_command_t *ita_attr;
	seg_env_t *seg_env, *seg_env1;
	pen_type_t type;
	uint32_t base_attr_id,_max_seg_size,_last_seg_size, seg_size,_offset;
	uint8_t_flags;
	bool_last, last_seg;
	chunk_t value, segment, seg;
	int_n;

	libimcv_init(FALSE);
	max_seg_size  = seg_env_tests[_i].max_seg_size;
	last_seg_size =_seg_env_tests[_i].last_seg_size;

	base_attr =_ita_attr_command_create(command);
	base_attr->build(base_attr);
	seg_env = seg_env_create(id, base_attr, max_seg_size);

	if (seg_env_tests[_i].next_segs == 0)
	{
		ck_assert(seg_env_==_NULL);
	}
	else
	{
		ck_assert(seg_env->get_base_attr_id(seg_env) == id);
		base_attr1_= seg_env->get_base_attr(seg_env);
		ck_assert(base_attr == base_attr1);
		base_attr1->destroy(base_attr1);

		for (n = 0; n <=_seg_env_tests[_i].next_segs; n++)
		{
		