else:
import pickle
+class StdOutRedirect(object):
+ def __init__(self,fileName):
+ import os,sys
+ sys.stderr.flush()
+ self.stdoutOld=os.dup(2)
+ self.fdOfSinkFile=os.open(fileName,os.O_CREAT | os.O_RDWR)
+ fd2=os.dup2(self.fdOfSinkFile,2)
+ self.origPyVal=sys.stderr
+ class FlushFile(object):
+ def __init__(self,f):
+ self.f=f
+ def write(self,st):
+ self.f.write(st)
+ self.f.flush()
+ def flush(self):
+ return self.f.flush()
+ def isatty(self):
+ return self.f.isatty()
+ sys.stderr=FlushFile(os.fdopen(self.fdOfSinkFile,"w"))
+ def __del__(self):
+ import os,sys
+ sys.stderr=self.origPyVal
+ if sys.version_info.major >= 3:
+ self.fdOfSinkFile.close()
+ pass
+ #os.fsync(self.fdOfSinkFile)
+ os.fsync(2)
+ os.dup2(self.stdoutOld,2)
+ os.close(self.stdoutOld)
+
class MEDLoaderTest3(unittest.TestCase):
def testMEDMesh1(self):
fileName="Pyfile18.med"
ff1.setFieldNoProfileSBT(f1)
a=ff1.getFieldOnMeshAtLevel(0,ON_CELLS,mm1)
self.assertEqual(a.getArray().getInfoOnComponents(),['power [MW/m^3]','density [g/cm^3]','temperature [K]'])
- self.assertTrue(a.isEqual(f1,1e-12,1e-12))
+ self.assertTrue(a.isEqual(f1,1e-12,0))
ff1.write(fname,0)
ff2=MEDFileAnyTypeField1TS.New(fname)
self.assertEqual(ff2.getName(),"VectorFieldOnCells")
self.assertTrue(isinstance(ff2,MEDFileIntField1TS))
a=ff1.getFieldOnMeshAtLevel(ON_CELLS,0,mm1)
self.assertEqual(a.getArray().getInfoOnComponents(),['power [MW/m^3]','density [g/cm^3]','temperature [K]'])
- self.assertTrue(a.isEqual(f1,1e-12,1e-12))
+ self.assertTrue(a.isEqual(f1,1e-12,0))
ff2.setTime(1,2,3.)
c=ff2.getUndergroundDataArray() ; c*=2
ff2.write(fname,0) # 2 time steps in
self.assertEqual(len(ffs1),2)
self.assertTrue(isinstance(ffs1,MEDFileIntFieldMultiTS))
a=ffs1[2.].getFieldOnMeshAtLevel(ON_CELLS,0,mm1)
- self.assertTrue(a.isEqual(f1,1e-12,1e-12))
+ self.assertTrue(a.isEqual(f1,1e-12,0))
a=ffs1.getFieldOnMeshAtLevel(ON_CELLS,0,1,0,mm1)
- self.assertTrue(a.isEqual(f1,1e-12,1e-12))
+ self.assertTrue(a.isEqual(f1,1e-12,0))
it=ffs1.__iter__() ; it.next() ; ff2bis=it.next()
a=ff2bis.getFieldOnMeshAtLevel(0,ON_CELLS,mm1)
self.assertTrue(a.getArray().isEqual(2*f1.getArray()))
f1.setTime(3.,1,2) ; f1.getArray()[:]*=2
- self.assertTrue(a.isEqual(f1,1e-12,1e-12)) ; f1.getArray()[:]/=2
+ self.assertTrue(a.isEqual(f1,1e-12,0)) ; f1.getArray()[:]/=2
bc=DataArrayInt(6,3) ; bc[:]=0 ; bc.setInfoOnComponents(['power [MW/m^3]','density [g/cm^3]','temperature [K]'])
for it in ffs1:
a=it.getFieldOnMeshAtLevel(ON_CELLS,0,mm1)
grpExp=grp+delta ; grpExp.setName("%s_node"%grp.getName())
self.assertTrue(mm.getGroupArr(1,"%s_node"%grp.getName()).isEqual(grpExp))
pass
-
- pass
+
def testMEDFileJoint1(self):
fileName="Pyfile92.med"
coo=DataArrayDouble([(0,0,0),(1,0,0),(2,0,0)])
self.assertRaises( InterpKernelException, jointsR.getJointAtPos,1)
self.assertRaises( InterpKernelException, jointsR.destroyJointAtPos,1)
jointsR.destroyJointAtPos(0)
-
- pass
+ pass
+
def testMEDFileJoint2(self):
fileNameWr="Pyfile93.med"
coo=DataArrayDouble([(0,0,0),(1,0,0),(2,0,0)])
""" EDF11242 : check status of MED file calls to detect problems immediately. Sorry this test generates awful messages !"""
fname="Pyfile94.med"
errfname="Pyfile94.err"
- class StdOutRedirect(object):
- def __init__(self,fileName):
- import os,sys
- sys.stderr.flush()
- self.stdoutOld=os.dup(2)
- self.fdOfSinkFile=os.open(fileName,os.O_CREAT | os.O_RDWR)
- fd2=os.dup2(self.fdOfSinkFile,2)
- self.origPyVal=sys.stderr
- class FlushFile(object):
- def __init__(self,f):
- self.f=f
- def write(self,st):
- self.f.write(st)
- self.f.flush()
- def flush(self):
- return self.f.flush()
- def isatty(self):
- return self.f.isatty()
- sys.stderr=FlushFile(os.fdopen(self.fdOfSinkFile,"w"))
- def __del__(self):
- import os,sys
- sys.stderr=self.origPyVal
- if sys.version_info.major >= 3:
- self.fdOfSinkFile.close()
- pass
- #os.fsync(self.fdOfSinkFile)
- os.fsync(2)
- os.dup2(self.stdoutOld,2)
- os.close(self.stdoutOld)
+
import os
# first clean file if needed
if os.path.exists(fname):
mm=MEDFileMesh.New(fname)
f1ts=MEDFileIntField1TS(fname,fieldName,6,7)
ftst0=f1ts.field(mm)
- self.assertTrue(f0.isEqual(ftst0,1e-12,1e-12))
+ self.assertTrue(f0.isEqual(ftst0,1e-12,0))
f1ts=MEDFileIntField1TS(fname,fieldName,8,9)
ftst1=f1ts.field(mm)
- self.assertTrue(f1.isEqual(ftst1,1e-12,1e-12))
+ self.assertTrue(f1.isEqual(ftst1,1e-12,0))
fmts=MEDFileIntFieldMultiTS(fname,fieldName)
- self.assertTrue(f1.isEqual(fmts.field(8,9,mm),1e-12,1e-12))
+ self.assertTrue(f1.isEqual(fmts.field(8,9,mm),1e-12,0))
## Basic test on nodes on top level
f2=MEDCouplingFieldInt(ON_NODES) ; arr2=DataArrayInt([200,201,202]) ; arr2.setInfoOnComponent(0,"tutu") ; f2.setArray(arr2) ; f2.setMesh(m) ; f2.setTime(22.,23,24)
f2.setName(fieldName)
#
mm=MEDFileMesh.New(fname)
f1ts=MEDFileIntField1TS(fname,fieldName,23,24)
- self.assertTrue(f2.isEqual(f1ts.field(mm),1e-12,1e-12))
+ self.assertTrue(f2.isEqual(f1ts.field(mm),1e-12,0))
fmts=MEDFileIntFieldMultiTS(fname,fieldName)
- self.assertTrue(f2.isEqual(fmts.field(23,24,mm),1e-12,1e-12))
+ self.assertTrue(f2.isEqual(fmts.field(23,24,mm),1e-12,0))
## Node on elements
f3=MEDCouplingFieldInt(ON_GAUSS_NE) ; f3.setMesh(m) ; arr3=DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]) ; f3.setArray(arr3) ; f3.setTime(0.5,2,3)
f3.setName(fieldName) ; f3.checkConsistencyLight()
#
mm=MEDFileMesh.New(fname)
f1ts=MEDFileIntField1TS(fname,fieldName,2,3)
- self.assertTrue(f3.isEqual(f1ts.field(mm),1e-12,1e-12))
+ self.assertTrue(f3.isEqual(f1ts.field(mm),1e-12,0))
## Gauss
f4=MEDCouplingFieldInt(ON_GAUSS_PT) ; f4.setMesh(m) ; f4.setName(fieldName)
f4.setGaussLocalizationOnType(NORM_TRI3,[0.,0.,1.,0.,1.,1.],[0.1,0.1, 0.2,0.2, 0.3,0.3, 0.4,0.4, 0.5,0.5],[0.2,0.3,0.1,0.05,0.35])
#
mm=MEDFileMesh.New(fname)
f1ts=MEDFileIntField1TS(fname,fieldName,4,5)
- self.assertTrue(f4.isEqual(f1ts.field(mm),1e-12,1e-12))
+ self.assertTrue(f4.isEqual(f1ts.field(mm),1e-12,0))
pass
def testMEDFileFieldEasyField3(self):
f1ts=MEDFileIntField1TS() ; f1ts.setFieldNoProfileSBT(f1) ; f1ts.write(fname,0)
#
mm=MEDFileMesh.New(fname) ; f1ts=MEDFileIntField1TS(fname,fieldName,1,2)
- self.assertTrue(f1.isEqual(f1ts.field(mm),1e-12,1e-12))
+ self.assertTrue(f1.isEqual(f1ts.field(mm),1e-12,0))
# here f1 lying on level -1 not 0 check if "field" method detect it !
f1=MEDCouplingFieldInt(ON_CELLS) ; f1.setName(fieldName) ; f1.setArray(DataArrayInt([(0,100),(1,101),(0,100),(1,101),(0,100),(1,101)]))
f1.setMesh(mm[-1]) # -1 is very important
f1ts=MEDFileIntField1TS() ; f1ts.setFieldNoProfileSBT(f1) ; f1ts.write(fname,0)
#
mm=MEDFileMesh.New(fname) ; f1ts=MEDFileIntField1TS(fname,fieldName,3,4)
- self.assertTrue(f1.isEqual(f1ts.field(mm),1e-12,1e-12))
+ self.assertTrue(f1.isEqual(f1ts.field(mm),1e-12,0))
# nodes on elements
f3=MEDCouplingFieldInt(ON_GAUSS_NE)
f3.setMesh(mm[-1]) # this line is important
mm.write(fname,2) ; ff=MEDFileIntField1TS() ; ff.setFieldNoProfileSBT(f3) ; ff.write(fname,0)
#
mm=MEDFileMesh.New(fname) ; f1ts=MEDFileIntField1TS(fname,fieldName,2,3)
- self.assertTrue(f3.isEqual(f1ts.field(mm),1e-12,1e-12))
+ self.assertTrue(f3.isEqual(f1ts.field(mm),1e-12,0))
# gauss
f4=MEDCouplingFieldInt(ON_GAUSS_PT)
f4.setMesh(mm[-1]) # this line is important
f4.checkConsistencyLight()
mm.write(fname,2) ; ff=MEDFileIntField1TS() ; ff.setFieldNoProfileSBT(f4) ; ff.write(fname,0)
mm=MEDFileMesh.New(fname) ; f1ts=MEDFileIntField1TS(fname,fieldName,4,5)
- self.assertTrue(f4.isEqual(f1ts.field(mm),1e-12,1e-12))
+ self.assertTrue(f4.isEqual(f1ts.field(mm),1e-12,0))
pass
def testMEDFileFieldEasyField5(self):
fmts5=pickle.loads(st)
self.assertEqual(len(fs4[0]),len(fmts5))
self.assertTrue(isinstance(fmts5,MEDFileIntFieldMultiTS))
- self.assertTrue(fmts5[0].field(ms4[0]).isEqual((fs4[0][0]).field(ms4[0]),1e-12,1e-12))
+ self.assertTrue(fmts5[0].field(ms4[0]).isEqual((fs4[0][0]).field(ms4[0]),1e-12,0))
# MEDFileIntField1TS
st=pickle.dumps(fs4[0][0],pickle.HIGHEST_PROTOCOL)
f1ts6=pickle.loads(st)
self.assertTrue(isinstance(f1ts6,MEDFileIntField1TS))
- self.assertTrue(f1ts6.field(ms4[0]).isEqual((fs4[0][0]).field(ms4[0]),1e-12,1e-12))
+ self.assertTrue(f1ts6.field(ms4[0]).isEqual((fs4[0][0]).field(ms4[0]),1e-12,0))
# MEDFileParameters
self.testParameters1()# generates Pyfile56.med
params=MEDFileParameters("Pyfile56.med")
self.assertTrue(ff1.field(mm).isEqual(f3,1e-12,1e-12))
pass
+ def testFloat32InMEDFileFieldStar1(self):
+ """Like testInt32InMEDFileFieldStar1 but with float32 :)"""
+ fname="Pyfile114.med"
+ f1=MEDLoaderDataForTest.buildVecFieldOnCells_1();
+ f1=f1.convertToFloatField()
+ m1=f1.getMesh()
+ mm1=MEDFileUMesh.New()
+ mm1.setCoords(m1.getCoords())
+ mm1.setMeshAtLevel(0,m1)
+ mm1.setName(m1.getName())
+ mm1.write(fname,2)
+ ff1=MEDFileFloatField1TS()
+ ff1.setFieldNoProfileSBT(f1)
+ a=ff1.getFieldOnMeshAtLevel(0,ON_CELLS,mm1)
+ self.assertEqual(a.getArray().getInfoOnComponents(),['power [MW/m^3]','density [g/cm^3]','temperature [K]'])
+ self.assertTrue(a.isEqual(f1,1e-12,1e-12))
+ ff1.write(fname,0)
+ ff2=MEDFileAnyTypeField1TS.New(fname)
+ self.assertEqual(ff2.getName(),"VectorFieldOnCells")
+ self.assertEqual(ff2.getTime(),[0,1,2.0])
+ self.assertTrue(isinstance(ff2,MEDFileFloatField1TS))
+ a=ff1.getFieldOnMeshAtLevel(ON_CELLS,0,mm1)
+ self.assertEqual(a.getArray().getInfoOnComponents(),['power [MW/m^3]','density [g/cm^3]','temperature [K]'])
+ self.assertTrue(a.isEqual(f1,1e-12,1e-12))
+ ff2.setTime(1,2,3.)
+ c=ff2.getUndergroundDataArray() ; c*=2
+ ff2.write(fname,0) # 2 time steps in
+ ffs1=MEDFileAnyTypeFieldMultiTS.New(fname,"VectorFieldOnCells")
+ self.assertEqual(ffs1.getTimeSteps(),[(0, 1, 2.0), (1, 2, 3.0)])
+ self.assertEqual(len(ffs1),2)
+ self.assertTrue(isinstance(ffs1,MEDFileFloatFieldMultiTS))
+ a=ffs1[2.].getFieldOnMeshAtLevel(ON_CELLS,0,mm1)
+ self.assertTrue(a.isEqual(f1,1e-12,1e-12))
+ a=ffs1.getFieldOnMeshAtLevel(ON_CELLS,0,1,0,mm1)
+ self.assertTrue(a.isEqual(f1,1e-12,1e-12))
+ it=ffs1.__iter__() ; it.next() ; ff2bis=it.next()
+ a=ff2bis.getFieldOnMeshAtLevel(0,ON_CELLS,mm1)
+ self.assertTrue(a.getArray().isEqual(2*f1.getArray(),1e-7))
+ f1.setTime(3.,1,2) ; f1.getArray()[:]*=2
+ self.assertTrue(a.isEqual(f1,1e-12,1e-12)) ; f1.getArray()[:]/=2
+ bc=DataArrayFloat(6,3) ; bc[:]=0 ; bc.setInfoOnComponents(['power [MW/m^3]','density [g/cm^3]','temperature [K]'])
+ for it in ffs1:
+ a=it.getFieldOnMeshAtLevel(ON_CELLS,0,mm1)
+ bc+=a.getArray()
+ pass
+ self.assertTrue(bc.isEqual(3*f1.getArray(),1e-7))
+ nf1=MEDCouplingFieldFloat(ON_NODES)
+ nf1.setTime(9.,10,-1)
+ nf1.setMesh(f1.getMesh())
+ narr=DataArrayFloat(12,2) ; narr.setInfoOnComponents(["aa [u1]","bbbvv [ppp]"]) ; narr[:,0]=list(range(12)) ; narr[:,1]=2*narr[:,0]
+ nf1.setName("VectorFieldOnNodes") ; nf1.setArray(narr)
+ nff1=MEDFileFloatField1TS.New()
+ nff1.setFieldNoProfileSBT(nf1)
+ self.assertEqual(nff1.getInfo(),('aa [u1]','bbbvv [ppp]'))
+ self.assertEqual(nff1.getTime(),[10,-1,9.0])
+ nff1.write(fname,0)
+ #
+ nf2=MEDCouplingFieldFloat(ON_NODES)
+ nf2.setTime(19.,20,-11)
+ nf2.setMesh(f1.getMesh())
+ narr2=DataArrayFloat(8,2) ; narr.setInfoOnComponents(["aapfl [u1]","bbbvvpfl [ppp]"]) ; narr2[:,0]=list(range(8)) ; narr2[:,0]+=10 ; narr2[:,1]=3*narr2[:,0]
+ nf2.setName("VectorFieldOnNodesPfl") ; narr2.setName(nf2.getName()) ; nf2.setArray(narr2)
+ nff2=MEDFileFloatField1TS.New()
+ npfl=DataArrayInt([1,2,4,5,6,7,10,11]) ; npfl.setName("npfl")
+ nff2.setFieldProfile(nf2,mm1,0,npfl)
+ nff2.getFieldWithProfile(ON_NODES,0,mm1)
+ a,b=nff2.getFieldWithProfile(ON_NODES,0,mm1) ; b.setName(npfl.getName())
+ self.assertTrue(b.isEqual(npfl))
+ self.assertTrue(a.isEqual(narr2,1e-7))
+ nff2.write(fname,0)
+ nff2bis=MEDFileFloatField1TS(fname,"VectorFieldOnNodesPfl")
+ a,b=nff2bis.getFieldWithProfile(ON_NODES,0,mm1) ; b.setName(npfl.getName())
+ self.assertTrue(b.isEqual(npfl))
+ self.assertTrue(a.isEqual(narr2,1e-7))
+ #
+ nf3=MEDCouplingFieldDouble(ON_NODES)
+ nf3.setName("VectorFieldOnNodesDouble")
+ nf3.setTime(29.,30,-21)
+ nf3.setMesh(f1.getMesh())
+ nf3.setArray(f1.getMesh().getCoords())
+ nff3=MEDFileField1TS.New()
+ nff3.setFieldNoProfileSBT(nf3)
+ nff3.write(fname,0)
+ fs=MEDFileFields(fname)
+ self.assertEqual(len(fs),4)
+ ffs=[it for it in fs]
+ self.assertTrue(isinstance(ffs[0],MEDFileFloatFieldMultiTS))
+ self.assertTrue(isinstance(ffs[1],MEDFileFloatFieldMultiTS))
+ self.assertTrue(isinstance(ffs[2],MEDFileFieldMultiTS))
+ self.assertTrue(isinstance(ffs[3],MEDFileFloatFieldMultiTS))
+ #
+ self.assertTrue(fs["VectorFieldOnCells"][0].getUndergroundDataArray().isEqualWithoutConsideringStr(f1.getArray(),1e-7))
+ self.assertTrue(fs["VectorFieldOnCells"][1,2].getUndergroundDataArray().isEqualWithoutConsideringStr(2*f1.getArray(),1e-7))
+ self.assertTrue(fs["VectorFieldOnNodesPfl"][0].getUndergroundDataArray().isEqualWithoutConsideringStr(narr2,1e-7))
+ self.assertTrue(fs["VectorFieldOnNodes"][9.].getUndergroundDataArray().isEqualWithoutConsideringStr(narr,1e-7))
+ self.assertTrue(fs["VectorFieldOnNodesDouble"][29.].getUndergroundDataArray().isEqualWithoutConsideringStr(f1.getMesh().getCoords(),1e-12))
+ #
+ nf3_read=MEDFileFieldMultiTS(fname,"VectorFieldOnNodesDouble")
+ self.assertTrue(nf3_read[29.].getUndergroundDataArray().isEqualWithoutConsideringStr(f1.getMesh().getCoords(),1e-12))
+ self.assertRaises(InterpKernelException,MEDFileFloatFieldMultiTS.New,fname,"VectorFieldOnNodesDouble")# exception because trying to read a double field with int instance
+ self.assertRaises(InterpKernelException,MEDFileFieldMultiTS.New,fname,"VectorFieldOnNodes")# exception because trying to read a int field with double instance
+ MEDFileField1TS.New(fname,"VectorFieldOnNodesDouble",30,-21)
+ self.assertRaises(InterpKernelException,MEDFileFloatField1TS.New,fname,"VectorFieldOnNodesDouble",30,-21)# exception because trying to read a double field with int instance
+ MEDFileFloatField1TS.New(fname,"VectorFieldOnNodes",10,-1)
+ self.assertRaises(InterpKernelException,MEDFileField1TS.New,fname,"VectorFieldOnNodes",10,-1)# exception because trying to read a double field with int instance
+ #
+ self.assertEqual(fs.getMeshesNames(),('3DSurfMesh_1','3DSurfMesh_1','3DSurfMesh_1','3DSurfMesh_1'))
+ self.assertTrue(fs.changeMeshNames([('3DSurfMesh_1','3DSurfMesh')]))
+ self.assertEqual(fs.getMeshesNames(),('3DSurfMesh','3DSurfMesh','3DSurfMesh','3DSurfMesh'))
+ self.assertTrue(not fs.changeMeshNames([('3DSurfMesh_1','3DSurfMesh')]))
+ pass
+
+ def testPenta18_1(self):
+ """EDF8478 : Test of read/write of penta18"""
+ fname="Pyfile115.med"
+ arr=DataArrayDouble([
+ (0.,1.,1.),(0.,0.,1.),(1.,0.,1.),
+ (0.,1.,0.),(0.,0.,0.),(1.,0.,0.),
+ (0.,0.5,1.),(0.5,0.,1.),(0.5,0.5,1.),
+ (0.,0.5,0.),(0.5,0.,0.),(0.5,0.5,0.),
+ (0.,1.,0.5),(0.,0.,0.5),(1.,0.,0.5),
+ (0.,0.5,0.5),(0.5,0.,0.5),(0.5,0.5,0.5)])
+ m=MEDCouplingUMesh("mesh",3)
+ m.setCoords(arr)
+ m.allocateCells(1)
+ m.insertNextCell(NORM_PENTA18,list(range(18)))
+ m.checkConsistencyLight()
+ #
+ f=MEDCouplingFieldDouble(ON_NODES)
+ f.setMesh(m)
+ f.setName("FieldOnPenta18")
+ f.setArray(DataArrayDouble(list(range(18))))
+ f.checkConsistencyLight()
+ #
+ m2,d,di,rd,rdi=m.buildDescendingConnectivity()
+ #
+ f2=MEDCouplingFieldDouble(ON_NODES)
+ f2.setMesh(m)
+ f2.setName("FieldOnPenta18Sub")
+ f2.setArray(DataArrayDouble(list(range(18))))
+ f2.checkConsistencyLight()
+ WriteField(fname,f2,True)
+ f3=ReadField(fname)
+ self.assertTrue(f2.isEqual(f3,1e-12,1e-12))
+ self.assertEqual(f3.getMesh().getNumberOfCells(),1)
+ self.assertEqual(f3.getMesh().getTypeOfCell(0),NORM_PENTA18)
+ pass
+
+ @unittest.skipUnless('linux'==platform.system().lower(),"stderr redirection not ported on Windows ?")
+ def testMedFileCapabilityToCryOnNewFeatureWritingIntoOldFiles(self):
+ fname="Pyfile116.med"
+ errfname="Pyfile116.err"
+ c=DataArrayDouble([0,1,2,3])
+ m=MEDCouplingCMesh()
+ m.setCoords(c,c)
+ m=m.buildUnstructured()
+ m.setName("mesh")
+ mm=MEDFileUMesh()
+ mm[0]=m
+ f=MEDCouplingFieldInt(ON_CELLS)
+ f.setMesh(m) ; arr2=DataArrayInt(m.getNumberOfCells()) ; arr2.iota()
+ f.setArray(arr2)
+ f.setName("field")
+ f1ts=MEDFileIntField1TS()
+ f1ts.setFieldNoProfileSBT(f)
+ mm.write30(fname,2)
+ f1ts.write30(fname,0)
+ #
+ f=MEDCouplingFieldFloat(ON_CELLS)
+ f.setMesh(m) ; arr2=DataArrayFloat(m.getNumberOfCells()) ; arr2.iota()
+ f.setArray(arr2)
+ f.setName("field2")
+ f1ts=MEDFileFloatField1TS()
+ f1ts.setFieldNoProfileSBT(f)
+ #
+ import os,gc
+ tmp=StdOutRedirect(errfname)
+ self.assertRaises(InterpKernelException,f1ts.write30,fname,0)
+ del tmp
+ gc.collect(0)
+ if os.path.exists(errfname):
+ os.remove(errfname)
+ pass
+
pass
if __name__ == "__main__":
