class ErtShellTestContext(object):
def __init__(self, test_name, config_file, load_config=True, prefix=None, store_area=False):
self.config_file = config_file
self.load_config = load_config
self.test_area_context = TestAreaContext(test_name, prefix=prefix, store_area=store_area)
def __enter__(self):
""" :rtype: ErtShell """
test_area = self.test_area_context.__enter__()
test_area.copy_parent_content(self.config_file)
self.shell = ErtShell(forget_history=True)
config_file = os.path.basename(self.config_file)
if self.load_config:
self.shell.onecmd("load_config %s" % config_file)
return self.shell
def __exit__(self, exc_type, exc_val, exc_tb):
self.shell.do_exit("")
self.shell._cleanup()
self.test_area_context.__exit__(exc_type, exc_val, exc_tb)
return False
def test_ert_script_from_file(self):
with TestAreaContext("python/job_queue/ert_script") as work_area:
ErtScriptTest.createScripts()
script_object = ErtScript.loadScriptFromFile("subtract_script.py")
script = script_object("ert")
result = script.initializeAndRun([int, int], ["1", "2"])
self.assertEqual(result, -1)
# with self.assertRaises(ErtScriptError):
self.assertIsNone(
ErtScript.loadScriptFromFile("syntax_error_script.py"))
self.assertIsNone(
ErtScript.loadScriptFromFile("import_error_script.py"))
self.assertIsNone(ErtScript.loadScriptFromFile("empty_script.py"))
def test_parse(self):
p = Parser()
pm = ParseContext()
with self.assertRaises(IOError):
p.parseFile("does/not/exist" , pm)
with TestAreaContext("parse-test"):
with open("test.DATA", "w") as fileH:
fileH.write("RUNSPEC\n")
fileH.write("DIMENS\n")
fileH.write(" 10 10 10 /\n")
deck = p.parseFile( "test.DATA" , pm)
self.assertEqual( len(deck) , 2 )
deck = Parser.parseFile( "test.DATA" )
def test_context(self):
with TestAreaContext("python/fortio/context") as t:
kw1 = EclKW("KW", 2456, EclTypeEnum.ECL_FLOAT_TYPE)
for i in range(len(kw1)):
kw1[i] = randint(0, 1000)
with openFortIO("file", mode=FortIO.WRITE_MODE) as f:
kw1.fwrite(f)
self.assertEqual(f.filename(), "file")
t.sync()
with openFortIO("file") as f:
kw2 = EclKW.fread(f)
self.assertTrue(kw1 == kw2)
def test_coarse(self):
#work_area = TestArea("python/grid-test/testCoarse")
with TestAreaContext("python/grid-test/testCoarse"):
testGRID = True
g1 = EclGrid(self.createTestPath("Statoil/ECLIPSE/LGCcase/LGC_TESTCASE2.EGRID"))
g1.save_EGRID("LGC.EGRID")
g2 = EclGrid("LGC.EGRID")
self.assertTrue(g1.equal(g2, verbose=True))
if testGRID:
g1.save_GRID("LGC.GRID")
g3 = EclGrid("LGC.GRID")
self.assertTrue(g1.equal(g3, verbose=True))
self.assertTrue(g1.coarse_groups() == 3384)
def test_field_guess_filetype(self):
with TestAreaContext('field_config') as test_context:
fname = abspath('test.kw.grdecl')
print(fname)
with open(fname, 'w') as f:
f.write("-- my comment\n")
f.write("-- more comments\n")
f.write("SOWCR\n")
for i in range(256 //
8): # technicalities demand file has >= 256B
f.write("0 0 0 0\n")
ft = FieldConfig.guessFiletype(fname)
grdecl_type = EnkfFieldFileFormatEnum(5)
self.assertEqual('ECL_GRDECL_FILE', grdecl_type.name)
self.assertEqual(grdecl_type, ft)
def test_various_null_fields(self):
for key in [
"target_file",
"error_file",
"start_file",
"stdout",
"stderr",
"max_running_minutes",
"argList",
"environment",
"stdin"
]:
with TestAreaContext("python/job_queue/forward_model_none_" + key):
back_up = joblist[0][key]
joblist[0][key] = None
self.run_all()
joblist[0][key] = back_up
def test_fortio_read_and_write(self):
with TestAreaContext("python/fortio/read_and_write"):
f = FortIO("test", FortIO.WRITE_MODE)
record_size = 4000
for i, c in enumerate("abcdefghijklmnopqrstuvwxyz"):
data = bytearray(c * record_size)
f.writeRecord(data)
position = f.getPosition()
self.assertEqual(position, (i + 1) * (record_size + 8))
f = FortIO("test", FortIO.READ_MODE)
for c in "abcdefghijklmnopqrstuvwxyz":
record = f.readRecordAsString(record_size)
self.assertEqual(record, c * record_size)
def test_save(self):
with TestAreaContext("python/grid-test/testSave"):
g1 = EclGrid(self.egrid_file())
g1.save_EGRID("test.EGRID")
g2 = EclGrid("test.EGRID")
self.assertTrue(g1.equal(g2))
g1.save_GRID("test.GRID")
g2 = EclGrid("test.GRID")
self.assertTrue(g1.equal(g2))
fileH = open("test.grdecl", "w")
g1.save_grdecl(fileH)
fileH.close()
g2 = self.create("test.grdecl")
self.assertTrue(g1.equal(g2))
def test_contact(self):
nx = 20
ny = 10
layer = Layer(nx,ny)
grid = EclGrid.createRectangular( (nx,ny,1) , (1,1,1) )
with self.assertRaises(IndexError):
layer.cellContact( (-1,0),(1,1) )
with self.assertRaises(IndexError):
layer.cellContact( (20,0),(1,1) )
self.assertFalse( layer.cellContact((0,0) , (2,0)) )
self.assertFalse( layer.cellContact((1,0) , (1,0)) )
self.assertTrue( layer.cellContact((0,0) , (1,0)) )
self.assertTrue( layer.cellContact((1,0) , (0,0)) )
self.assertTrue( layer.cellContact((0,0) , (0,1)) )
self.assertTrue( layer.cellContact((0,1) , (0,0)) )
self.assertFalse( layer.cellContact((0,0) , (1,1)) )
self.assertFalse( layer.cellContact((1,1) , (0,0)) )
self.assertTrue( layer.cellContact((4,0) , (5,0)) )
self.assertTrue( layer.cellContact((0,4) , (0,5)) )
with TestAreaContext("Layer/barrier"):
with open("faults.grdecl" , "w") as f:
f.write("FAULTS\n")
f.write("\'FX\' 5 5 1 10 1 1 'X' /\n")
f.write("\'FY\' 1 10 5 5 1 1 'Y' /\n")
f.write("/")
faults = FaultCollection( grid , "faults.grdecl")
layer.addFaultBarrier( faults["FX"] , 0 )
self.assertFalse( layer.cellContact((4,0) , (5,0)) )
layer.addFaultBarrier( faults["FY"] , 0 )
self.assertFalse( layer.cellContact((0,4) , (0,5)) )
self.assertFalse( layer.cellContact((9,4) , (9,5)) )
self.assertTrue( layer.cellContact((10,4) , (10,5)) )
def test_create(self):
data_config = GenDataConfig("KEY")
with self.assertRaises(ValueError):
gen_obs = GenObservation("KEY", data_config)
with TestAreaContext("gen_obs/create"):
with open("obs1.txt", "w") as f:
f.write("10 5 12 6\n")
with self.assertRaises(ValueError):
gen_obs = GenObservation("KEY",
data_config,
scalar_value=(1, 2),
obs_file="obs1.txt")
with self.assertRaises(TypeError):
gen_obs = GenObservation("KEY", data_config, scalar_value=1)
with self.assertRaises(IOError):
gen_obs = GenObservation("KEY",
data_config,
obs_file="does/not/exist")
gen_obs = GenObservation("KEY",
data_config,
obs_file="obs1.txt",
data_index="10,20")
self.assertEqual(len(gen_obs), 2)
self.assertEqual(gen_obs[0], (10, 5))
self.assertEqual(gen_obs[1], (12, 6))
self.assertEqual(gen_obs.getValue(0), 10)
self.assertEqual(gen_obs.getDataIndex(1), 20)
self.assertEqual(gen_obs.getStdScaling(0), 1)
self.assertEqual(gen_obs.getStdScaling(1), 1)
active_list = ActiveList()
gen_obs.updateStdScaling(0.25, active_list)
self.assertEqual(gen_obs.getStdScaling(0), 0.25)
self.assertEqual(gen_obs.getStdScaling(1), 0.25)
active_list.addActiveIndex(1)
gen_obs.updateStdScaling(2.00, active_list)
self.assertEqual(gen_obs.getStdScaling(0), 0.25)
self.assertEqual(gen_obs.getStdScaling(1), 2.00)
def test_ecl_config_creation(self):
with TestAreaContext("enkf_library_test") as work_area:
work_area.copy_directory(self.case_directory)
main = EnKFMain("simple_config/minimum_config", self.site_config)
self.assertIsInstance(main.analysisConfig(), AnalysisConfig)
self.assertIsInstance(main.eclConfig(), EclConfig)
with self.assertRaises(AssertionError): # Null pointer!
self.assertIsInstance(main.eclConfig().getRefcase(), EclSum)
file_system = main.getEnkfFsManager().getCurrentFileSystem()
self.assertEqual(file_system.getCaseName(), "default")
time_map = file_system.getTimeMap()
self.assertIsInstance(time_map, TimeMap)
main.free()
def test_missing_smspec_keyword(self):
with TestAreaContext("EclSum/truncated_data") as ta:
ta.copy_file( self.test_file )
ta.copy_file( self.createTestPath( "Statoil/ECLIPSE/Gurbat/ECLIPSE.UNSMRY" ))
with openEclFile("ECLIPSE.SMSPEC") as f:
kw_list = []
for kw in f:
kw_list.append(EclKW.copy( kw ) )
with openFortIO("ECLIPSE.SMSPEC" , mode = FortIO.WRITE_MODE) as f:
for kw in kw_list:
if kw.getName() == "KEYWORDS":
continue
kw.fwrite(f)
with self.assertRaises(IOError):
EclSum( "ECLIPSE" )
def test_connect(self):
with TestAreaContext("server/socket") as work_area:
work_area.copy_directory_content(self.config_path)
pid = os.fork()
if pid == 0:
s = ErtSocket.connect(self.config_file , self.port , self.host , self.logger)
s.listen( )
else:
time.sleep(0.50)
self.runCommand( ["STATUS"] , ["OPEN"] )
self.runCommand( ["QUIT"] , ["QUIT"] )
with self.assertRaises(Exception):
self.runCommand( "INVALID" )
with self.assertRaises(Exception):
self.runCommand( ["MISSING_COMMAND"] )
def test_gen_kw_get_set_vector(self):
with TestAreaContext("enkf/data/gen_kwt"):
(gen_kw_config, gen_kw) = create_gen_kw()
with self.assertRaises(ValueError):
gen_kw.setValues([0])
with self.assertRaises(TypeError):
gen_kw.setValues(["A", "B", "C"])
gen_kw.setValues([0, 1, 2])
self.assertEqual(gen_kw[0], 0)
self.assertEqual(gen_kw[1], 1)
self.assertEqual(gen_kw[2], 2)
self.assertEqual(gen_kw["MULTFLT1"], 0)
self.assertEqual(gen_kw["MULTFLT2"], 1)
self.assertEqual(gen_kw["MULTFLT3"], 2)
def test_gen_kw_get_set(self):
with TestAreaContext("enkf/data/gen_kwt"):
(gen_kw_config, gen_kw) = create_gen_kw()
self.assertIsInstance(gen_kw, GenKw)
gen_kw[0] = 3.0
self.assertEqual(gen_kw[0], 3.0)
gen_kw["MULTFLT1"] = 4.0
self.assertEqual(gen_kw["MULTFLT1"], 4.0)
self.assertEqual(gen_kw[0], 4.0)
gen_kw["MULTFLT2"] = 8.0
self.assertEqual(gen_kw["MULTFLT2"], 8.0)
self.assertEqual(gen_kw[1], 8.0)
gen_kw["MULTFLT3"] = 12.0
self.assertEqual(gen_kw["MULTFLT3"], 12.0)
self.assertEqual(gen_kw[2], 12.0)
self.assertEqual(len(gen_kw), 3)
with self.assertRaises(IndexError):
gen_kw[4]
with self.assertRaises(TypeError):
gen_kw[1.5]
with self.assertRaises(KeyError):
gen_kw["MULTFLT_2"]
self.assertTrue("MULTFLT1" in gen_kw)
items = gen_kw.items()
self.assertEqual(len(items), 3)
self.assertEqual(items[0][0], "MULTFLT1")
self.assertEqual(items[1][0], "MULTFLT2")
self.assertEqual(items[2][0], "MULTFLT3")
self.assertEqual(items[0][1], 4)
self.assertEqual(items[1][1], 8)
self.assertEqual(items[2][1], 12)
def test_cleanup(self):
with TestAreaContext("latex") as work_area:
work_area.copy_directory_content(self.statoil_path)
lx = LaTeX("report_OK.tex", in_place=True)
self.assertTrue(lx.in_place)
self.assertTrue(lx.compile())
for ext in ["log", "aux", "nav", "out", "snm", "toc"]:
self.assertFalse(os.path.exists("report_OK.%s" % ext))
lx = LaTeX("%s/report_OK.tex" % self.statoil_path, in_place=False)
self.assertFalse(lx.in_place)
run_path = lx.runpath
self.assertTrue(lx.compile())
self.assertFalse(os.path.exists(run_path))
lx = LaTeX("%s/report_OK.tex" % self.statoil_path, in_place=False)
run_path = lx.runpath
self.assertTrue(lx.compile(cleanup=False))
self.assertTrue(os.path.exists("%s/report_OK.log" % run_path))
def test_temp_area(self):
with TestAreaContext("TestArea") as test_area:
cwd = os.getcwd()
with open("file.txt", "w") as f:
f.write("File")
with TempAreaContext("TempArea") as temp_area:
self.assertEqual(cwd, os.getcwd())
self.assertEqual(cwd, temp_area.get_cwd())
temp_area.copy_file("file.txt")
self.assertTrue(
os.path.isfile(
os.path.join(temp_area.getPath(), "file.txt")))
os.mkdir("tmp")
os.chdir("tmp")
self.assertEqual(os.getcwd(), os.path.join(cwd, "tmp"))
def test_fprintf_data(self):
with TestAreaContext("kw_no_header"):
kw = EclKW.create("REGIONS", 10, EclTypeEnum.ECL_INT_TYPE)
for i in range(len(kw)):
kw[i] = i
fileH = open("test", "w")
kw.fprintf_data(fileH)
fileH.close()
fileH = open("test", "r")
data = []
for line in fileH.readlines():
tmp = line.split()
for elm in tmp:
data.append(int(elm))
for (v1, v2) in zip(data, kw):
self.assertEqual(v1, v2)
def test_num_linesegment(self):
nx = 10
ny = 10
nz = 1
grid = EclGrid.createRectangular((nx, ny, nz), (1, 1, 1))
with TestAreaContext("python/faults/line_order"):
with open("faults.grdecl", "w") as f:
f.write("""FAULTS
\'F1\' 1 4 2 2 1 1 \'Y\' /
\'F1\' 6 8 2 2 1 1 \'Y\' /
\'F2\' 1 8 2 2 1 1 \'Y\' /
/
""")
faults = FaultCollection(grid, "faults.grdecl")
f1 = faults["F1"]
f2 = faults["F2"]
self.assertEqual(2, f1.numLines(0))
self.assertEqual(1, f2.numLines(0))
def test_arguments(self):
with TestAreaContext("python/job_queue/workflow_job") as work_area:
WorkflowCommon.createInternalFunctionJob()
config = alloc_config()
job = alloc_from_file("PRINTF", config, "printf_job")
self.assertEqual(job.minimumArgumentCount(), 4)
self.assertEqual(job.maximumArgumentCount(), 5)
self.assertEqual(job.argumentTypes(), [str, int, float, bool, str])
self.assertTrue(job.run(None, ["x %d %f %d", 1, 2.5, True]))
self.assertTrue(job.run(None, ["x %d %f %d %s", 1, 2.5, True, "y"]))
with self.assertRaises(UserWarning): # Too few arguments
job.run(None, ["x %d %f", 1, 2.5])
with self.assertRaises(UserWarning): # Too many arguments
job.run(None, ["x %d %f %d %s", 1, 2.5, True, "y", "nada"])
def test_gc(self):
kw1 = EclKW("KW1", 100, EclTypeEnum.ECL_INT_TYPE)
kw2 = EclKW("KW2", 100, EclTypeEnum.ECL_INT_TYPE)
kw3 = EclKW("KW3", 100, EclTypeEnum.ECL_INT_TYPE)
for i in range(len(kw1)):
kw1[i] = i
kw2[i] = 2 * i
kw3[i] = 3 * i
kw_list = [kw1, kw2, kw2]
with TestAreaContext("context") as ta:
createFile("TEST", kw_list)
gc.collect()
kw_list2 = loadKeywords("TEST")
for kw1, kw2 in zip(kw_list, kw_list2):
self.assertEqual(kw1, kw2)
def test_collection(self):
"""Testing len, adding, getting (idx and slice), printing, clearing."""
def path(idx):
return 'path_%d' % idx
def base(idx):
return 'base_%d' % idx
with TestAreaContext("runpath_list"):
runpath_list = RunpathList("EXPORT.txt")
runpath_list.add(3, 1, path(3), base(3))
runpath_list.add(1, 1, path(1), base(1))
runpath_list.add(2, 1, path(2), base(2))
runpath_list.add(0, 0, path(0), base(0))
runpath_list.add(3, 0, path(3), base(3))
runpath_list.add(1, 0, path(1), base(1))
runpath_list.add(2, 0, path(2), base(2))
runpath_list.add(0, 1, path(0), base(0))
self.assertEqual(8, len(runpath_list))
pfx = 'RunpathList(size' # the __repr__ function
self.assertEqual(pfx, repr(runpath_list)[:len(pfx)])
node2 = RunpathNode(2, 1, path(2), base(2))
self.assertEqual(node2, runpath_list[2])
node3 = RunpathNode(0, 0, path(0), base(0))
node4 = RunpathNode(3, 0, path(3), base(3))
node5 = RunpathNode(1, 0, path(1), base(1))
node6 = RunpathNode(2, 0, path(2), base(2))
nodeslice = [node3, node4, node5, node6]
self.assertEqual(nodeslice, runpath_list[3:7])
self.assertEqual(node6, runpath_list[-2])
with self.assertRaises(TypeError):
runpath_list["key"]
with self.assertRaises(IndexError):
runpath_list[12]
runpath_list.clear()
self.assertEqual(0, len(runpath_list))
with self.assertRaises(IndexError):
runpath_list[0]
self.assertEqual('EXPORT.txt', runpath_list.getExportFile())
def test_workflow_thread_cancel_ert_script(self):
with TestAreaContext(
"python/job_queue/workflow_runner_ert_script") as work_area:
WorkflowCommon.createWaitJob()
joblist = WorkflowJoblist()
self.assertTrue(joblist.addJobFromFile("WAIT", "wait_job"))
self.assertTrue("WAIT" in joblist)
workflow = Workflow("wait_workflow", joblist)
self.assertEqual(len(workflow), 3)
workflow_runner = WorkflowRunner(workflow)
self.assertFalse(workflow_runner.isRunning())
workflow_runner.run()
self.assertIsNone(workflow_runner.workflowResult())
time.sleep(1) # wait for workflow to start
self.assertTrue(workflow_runner.isRunning())
self.assertFileExists("wait_started_0")
time.sleep(1) # wait for first job to finish
workflow_runner.cancel()
time.sleep(1) # wait for cancel to take effect
self.assertFileExists("wait_finished_0")
self.assertFileExists("wait_started_1")
self.assertFileExists("wait_cancelled_1")
self.assertFileDoesNotExist("wait_finished_1")
self.assertTrue(workflow_runner.isCancelled())
workflow_runner.wait() # wait for runner to complete
self.assertFileDoesNotExist("wait_started_2")
self.assertFileDoesNotExist("wait_cancelled_2")
self.assertFileDoesNotExist("wait_finished_2")
def test_workflow_joblist_with_files(self):
with TestAreaContext("python/job_queue/workflow_joblist") as work_area:
WorkflowCommon.createErtScriptsJob()
WorkflowCommon.createExternalDumpJob()
WorkflowCommon.createInternalFunctionJob()
joblist = WorkflowJoblist()
joblist.addJobFromFile("DUMP_JOB", "dump_job")
joblist.addJobFromFile("SELECT_CASE_JOB", "select_case_job")
joblist.addJobFromFile("SUBTRACT_SCRIPT_JOB",
"subtract_script_job")
self.assertTrue("DUMP_JOB" in joblist)
self.assertTrue("SELECT_CASE_JOB" in joblist)
self.assertTrue("SUBTRACT_SCRIPT_JOB" in joblist)
self.assertFalse((joblist["DUMP_JOB"]).isInternal())
self.assertTrue((joblist["SELECT_CASE_JOB"]).isInternal())
self.assertTrue((joblist["SUBTRACT_SCRIPT_JOB"]).isInternal())
def test_connect(self):
port = self.base_port
config_path = self.createTestPath("local/resopt/config/simple")
with TestAreaContext("server/socket1") as work_area:
work_area.copy_directory_content(config_path)
self.startServer("config", port)
self.runCommand(["STATUS"], port, expected=["READY"])
with self.assertRaises(Exception):
self.runCommand("INVALID", port)
with self.assertRaises(Exception):
self.runCommand(["MISSING_COMMAND"], port)
self.runCommand(["QUIT"], port, expected=["QUIT"])
# Server is closed
with self.assertRaises(Exception):
self.runCommand(["STATUS"], port)
def testSimulations(self):
with TestAreaContext("server/server") as work_area:
work_area.copy_directory_content(self.config_path)
ert_server = ErtServer(self.config_file, self.logger)
cmd = ["INIT_SIMULATIONS"]
with self.assertRaises(IndexError):
res = ert_server.evalCmd(cmd)
cmd = ["UNKNOWN_COMMAND"]
with self.assertRaises(KeyError):
res = ert_server.evalCmd(cmd)
cmd = ["GET_RESULT"] # Missing arguments
with self.assertRaises(IndexError):
res = ert_server.evalCmd(cmd)
cmd = ["GET_RESULT", 1, 1, "KW"] #Missing keyword
with self.assertRaises(KeyError):
res = ert_server.evalCmd(cmd)
def test_IOError(self):
with TestAreaContext("TestArea") as test_area:
with self.assertRaises(IOError):
test_area.copy_file("Does/not/exist")
with self.assertRaises(IOError):
test_area.install_file("Does/not/exist")
with self.assertRaises(IOError):
test_area.copy_directory("Does/not/exist")
with self.assertRaises(IOError):
test_area.copy_parent_directory("Does/not/exist")
os.makedirs("path1/path2")
with open("path1/file.txt", "w") as f:
f.write("File ...")
with self.assertRaises(IOError):
test_area.copy_directory("path1/file.txt")
def test_kw_write(self):
with TestAreaContext("python/ecl_kw/writing"):
data = [random.random() for i in range(10000)]
kw = EclKW("TEST", len(data), EclTypeEnum.ECL_DOUBLE_TYPE)
i = 0
for d in data:
kw[i] = d
i += 1
pfx = 'EclKW('
self.assertEqual(pfx, repr(kw)[:len(pfx)])
fortio = FortIO("ECL_KW_TEST", FortIO.WRITE_MODE)
kw.fwrite(fortio)
fortio.close()
fortio = FortIO("ECL_KW_TEST")
kw2 = EclKW.fread(fortio)
self.assertTrue(kw.equal(kw2))
ecl_file = EclFile("ECL_KW_TEST",
flags=EclFileFlagEnum.ECL_FILE_WRITABLE)
kw3 = ecl_file["TEST"][0]
self.assertTrue(kw.equal(kw3))
ecl_file.save_kw(kw3)
ecl_file.close()
fortio = FortIO("ECL_KW_TEST", FortIO.READ_AND_WRITE_MODE)
kw4 = EclKW.fread(fortio)
self.assertTrue(kw.equal(kw4))
fortio.seek(0)
kw4.fwrite(fortio)
fortio.close()
ecl_file = EclFile("ECL_KW_TEST")
kw5 = ecl_file["TEST"][0]
self.assertTrue(kw.equal(kw5))
def test_str(self):
m = Matrix(2, 2)
s = "%s" % m
m[0,0] = 0
m[0,1] = 1
m[1,0] = 2
m[1,1] = 3
with TestAreaContext("matrix_fprint"):
with open("matrix.txt", "w") as f:
m.fprint( f )
with open("matrix.txt") as f:
l1 = [ float(x) for x in f.readline().split()]
l2 = [ float(x) for x in f.readline().split()]
self.assertEqual( l1[0] , m[0,0])
self.assertEqual( l1[1] , m[0,1])
self.assertEqual( l2[0] , m[1,0])
self.assertEqual( l2[1] , m[1,1])
def test_create(self):
with TestAreaContext("create_fs") as work_area:
work_area.copy_parent_content(self.config_file)
self.assertTrue(EnkfFs.exists(self.mount_point))
fs = EnkfFs(self.mount_point)
self.assertEqual(1, fs.refCount())
fs.umount()
self.assertFalse(EnkfFs.exists("newFS"))
arg = None
fs = EnkfFs.createFileSystem("newFS",
EnKFFSType.BLOCK_FS_DRIVER_ID, arg)
self.assertTrue(EnkfFs.exists("newFS"))
self.assertTrue(fs is None)
with self.assertRaises(IOError):
version = EnkfFs.diskVersion("does/not/exist")
version = EnkfFs.diskVersion("newFS")
self.assertTrue(version >= 106)
def __init__(self, test_name, config_file, load_config=True, prefix=None, store_area=False):
self.config_file = config_file
self.load_config = load_config
self.test_area_context = TestAreaContext(test_name, prefix=prefix, store_area=store_area)
